/src/liblnk/liblnk/liblnk_data_block.c

Source (jump to first uncovered line)
/*
 * Data block functions
 *
 * Copyright (C) 2009-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 <byte_stream.h>
#include <memory.h>
#include <types.h>

#include "liblnk_data_block.h"
#include "liblnk_libbfio.h"
#include "liblnk_libcerror.h"
#include "liblnk_libcnotify.h"

/* Creates a data block
 * Make sure the value data_block is referencing, is set to NULL
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_initialize(
     liblnk_data_block_t **data_block,
     libcerror_error_t **error )
{
  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_initialize";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  if( *data_block != NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
     "%s: invalid data block value already set.",
     function );

    return( -1 );
  }
  internal_data_block = memory_allocate_structure(
                         liblnk_internal_data_block_t );

  if( internal_data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
     "%s: unable to create data block.",
     function );

    goto on_error;
  }
  if( memory_set(
       internal_data_block,
       0,
       sizeof( liblnk_internal_data_block_t ) ) == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_SET_FAILED,
     "%s: unable to clear data block.",
     function );

    goto on_error;
  }
  *data_block = (liblnk_data_block_t *) internal_data_block;

  return( 1 );

on_error:
  if( internal_data_block != NULL )
  {
    memory_free(
     internal_data_block );
  }
  return( -1 );
}

/* Frees a data block
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_free(
     liblnk_data_block_t **data_block,
     libcerror_error_t **error )
{
  static char *function = "liblnk_data_block_free";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  if( *data_block != NULL )
  {
    *data_block = NULL;
  }
  return( 1 );
}

/* Frees a data block
 * Returns 1 if successful or -1 on error
 */
int liblnk_internal_data_block_free(
     liblnk_internal_data_block_t **internal_data_block,
     libcerror_error_t **error )
{
  static char *function = "liblnk_internal_data_block_free";
  int result            = 1;

  if( internal_data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  if( *internal_data_block != NULL )
  {
    if( ( *internal_data_block )->value != NULL )
    {
      if( ( *internal_data_block )->free_value != NULL )
      {
        if( ( *internal_data_block )->free_value(
             &( ( *internal_data_block )->value ),
             error ) != 1 )
        {
          libcerror_error_set(
           error,
           LIBCERROR_ERROR_DOMAIN_RUNTIME,
           LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
           "%s: unable to free data block value.",
           function );

          result = -1;
        }
      }
    }
    if( ( *internal_data_block )->data != NULL )
    {
      memory_free(
       ( *internal_data_block )->data );
    }
    memory_free(
     *internal_data_block );

    *internal_data_block = NULL;
  }
  return( result );
}

/* Sets the data of a data block
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_set_data(
     liblnk_data_block_t *data_block,
     const uint8_t *data,
     size_t data_size,
     libcerror_error_t **error )
{
  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_set_data";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  internal_data_block = (liblnk_internal_data_block_t *) data_block;

  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 > MEMORY_MAXIMUM_ALLOCATION_SIZE )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid data size value out of bounds.",
     function );

    return( -1 );
  }
  internal_data_block->data = (uint8_t *) memory_allocate(
                                           sizeof( uint8_t ) * data_size );

  if( internal_data_block->data == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
     "%s: unable to create data block data.",
     function );

    goto on_error;
  }
  internal_data_block->data_size = data_size;

  if( memory_copy(
       internal_data_block->data,
       data,
       data_size ) == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_COPY_FAILED,
     "%s: unable to copy data.",
     function );

    goto on_error;
  }
  return( 1 );

on_error:
  if( internal_data_block->data != NULL )
  {
    memory_free(
     internal_data_block->data );

    internal_data_block->data = NULL;
  }
  internal_data_block->size = 0;

  return( -1 );
}

/* Reads a data block
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_read_data(
     liblnk_data_block_t *data_block,
     const uint8_t *data,
     size_t data_size,
     libcerror_error_t **error )
{
  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_read_data";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  internal_data_block = (liblnk_internal_data_block_t *) data_block;

  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 < 4 )
   || ( data_size > (size_t) SSIZE_MAX ) )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid data size value out of bounds.",
     function );

    return( -1 );
  }
#if defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: data block data:\n",
     function );
    libcnotify_print_data(
     data,
     data_size,
     LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
  }
#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  byte_stream_copy_to_uint32_little_endian(
   data,
   internal_data_block->signature );

#if defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: data block signature\t\t\t: 0x%08" PRIx32 "\n",
     function,
     internal_data_block->signature );

    if( data_size > 4 )
    {
      libcnotify_printf(
       "%s: data block data:\n",
       function );
      libcnotify_print_data(
       &( data[ 4 ] ),
       data_size - 4,
       LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
    }
  }
#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  return( 1 );
}

/* Reads a data block
 * Returns the number of bytes read if successful or -1 on error
 */
int liblnk_data_block_read_file_io_handle(
     liblnk_data_block_t *data_block,
     liblnk_io_handle_t *io_handle,
     libbfio_handle_t *file_io_handle,
     off64_t file_offset,
     libcerror_error_t **error )
{
  uint8_t data_block_size_data[ 4 ];

  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_read_file_io_handle";
  ssize_t read_count                                = 0;

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  internal_data_block = (liblnk_internal_data_block_t *) data_block;

  if( internal_data_block->data != NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
     "%s: invalid data block - data already set.",
     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 defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: reading data block at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",
     function,
     file_offset,
     file_offset );
  }
#endif
  read_count = libbfio_handle_read_buffer_at_offset(
          file_io_handle,
          data_block_size_data,
          4,
          file_offset,
          error );

  if( read_count != (ssize_t) 4 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_IO,
     LIBCERROR_IO_ERROR_READ_FAILED,
     "%s: unable to read data block size at offset: %" PRIi64 " (0x%08" PRIx64 ").",
     function,
     file_offset,
     file_offset );

    goto on_error;
  }
  byte_stream_copy_to_uint32_little_endian(
   data_block_size_data,
   internal_data_block->size );

#if defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: data block size\t\t\t: %" PRIu32 "\n",
     function,
     internal_data_block->size );
  }
#endif
  if( internal_data_block->size > 0 )
  {
    if( ( internal_data_block->size < 4 )
     || ( internal_data_block->size > ( MEMORY_MAXIMUM_ALLOCATION_SIZE + 4 ) ) )
    {
      libcerror_error_set(
       error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
       "%s: invalid data block size value out of bounds.",
       function );

      goto on_error;
    }
    internal_data_block->data_size = internal_data_block->size - 4;

    internal_data_block->data = (uint8_t *) memory_allocate(
                                             sizeof( uint8_t ) * internal_data_block->data_size );

    if( internal_data_block->data == NULL )
    {
      libcerror_error_set(
       error,
       LIBCERROR_ERROR_DOMAIN_MEMORY,
       LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
       "%s: unable to create data block data.",
       function );

      goto on_error;
    }
    if( (off64_t) internal_data_block->size > (off64_t) ( io_handle->file_size - file_offset ) )
    {
      libcerror_error_set(
       error,
       LIBCERROR_ERROR_DOMAIN_RUNTIME,
       LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
       "%s: invalid data block size value exceeds file size.",
       function );

      goto on_error;
    }
    read_count = libbfio_handle_read_buffer(
            file_io_handle,
            internal_data_block->data,
            internal_data_block->data_size,
            error );

    if( read_count != (ssize_t) internal_data_block->data_size )
    {
      libcerror_error_set(
       error,
       LIBCERROR_ERROR_DOMAIN_IO,
       LIBCERROR_IO_ERROR_READ_FAILED,
       "%s: unable to read data block data.",
       function );

      goto on_error;
    }
    if( liblnk_data_block_read_data(
         data_block,
         internal_data_block->data,
         internal_data_block->data_size,
         error ) != 1 )
    {
      libcerror_error_set(
       error,
       LIBCERROR_ERROR_DOMAIN_IO,
       LIBCERROR_IO_ERROR_READ_FAILED,
       "%s: unable to read data block.",
       function );

      goto on_error;
    }
  }
  internal_data_block->ascii_codepage = io_handle->ascii_codepage;

  return( 1 );

on_error:
  if( internal_data_block->data != NULL )
  {
    memory_free(
     internal_data_block->data );

    internal_data_block->data = NULL;
  }
  internal_data_block->size = 0;

  return( -1 );
}

/* Retrieves the size
 * Returns 1 if successful or -1 on error
 */
int liblnk_internal_data_block_get_size(
     liblnk_internal_data_block_t *internal_data_block,
     uint32_t *size,
     libcerror_error_t **error )
{
  static char *function = "liblnk_internal_data_block_get_size";

  if( internal_data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  if( size == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid size.",
     function );

    return( -1 );
  }
  *size = internal_data_block->size;

  return( 1 );
}

/* Retrieves the signature
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_get_signature(
     liblnk_data_block_t *data_block,
     uint32_t *signature,
     libcerror_error_t **error )
{
  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_get_signature";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  internal_data_block = (liblnk_internal_data_block_t *) data_block;

  if( internal_data_block->data_size < 4 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid data block - data size value out of bounds.",
     function );

    return( -1 );
  }
  if( signature == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid signature.",
     function );

    return( -1 );
  }
  *signature = internal_data_block->signature;

  return( 1 );
}

/* Retrieves the data block data size
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_get_data_size(
     liblnk_data_block_t *data_block,
     size_t *data_size,
     libcerror_error_t **error )
{
  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_get_data_size";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  internal_data_block = (liblnk_internal_data_block_t *) data_block;

  if( internal_data_block->data_size < 4 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid data block - data size value out of bounds.",
     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 );
  }
  *data_size = (size_t) internal_data_block->data_size - 4;

  return( 1 );
}

/* Copies the data block data to the buffer
 * Returns 1 if successful or -1 on error
 */
int liblnk_data_block_copy_data(
     liblnk_data_block_t *data_block,
     uint8_t *data,
     size_t data_size,
     libcerror_error_t **error )
{
  liblnk_internal_data_block_t *internal_data_block = NULL;
  static char *function                             = "liblnk_data_block_copy_data";

  if( data_block == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid data block.",
     function );

    return( -1 );
  }
  internal_data_block = (liblnk_internal_data_block_t *) data_block;

  if( internal_data_block->data_size < 4 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
     "%s: invalid data block - data size value out of bounds.",
     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 < (size_t) ( internal_data_block->data_size - 4 ) )
   || ( 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( memory_copy(
       data,
       &( internal_data_block->data[ 4 ] ),
       internal_data_block->data_size - 4 ) == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_COPY_FAILED,
     "%s: unable to copy data block data.",
     function );

    return( -1 );
  }
  return( 1 );
}


Coverage Report

Created: 2025-07-04 07:01

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Data block functions
3		*
4		* Copyright (C) 2009-2024, Joachim Metz <joachim.metz@gmail.com>
5		*
6		* Refer to AUTHORS for acknowledgements.
7		*
8		* This program is free software: you can redistribute it and/or modify
9		* it under the terms of the GNU Lesser General Public License as published by
10		* the Free Software Foundation, either version 3 of the License, or
11		* (at your option) any later version.
12		*
13		* This program is distributed in the hope that it will be useful,
14		* but WITHOUT ANY WARRANTY; without even the implied warranty of
15		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16		* GNU General Public License for more details.
17		*
18		* You should have received a copy of the GNU Lesser General Public License
19		* along with this program. If not, see <https://www.gnu.org/licenses/>.
20		*/
21
22		#include <common.h>
23		#include <byte_stream.h>
24		#include <memory.h>
25		#include <types.h>
26
27		#include "liblnk_data_block.h"
28		#include "liblnk_libbfio.h"
29		#include "liblnk_libcerror.h"
30		#include "liblnk_libcnotify.h"
31
32		/* Creates a data block
33		* Make sure the value data_block is referencing, is set to NULL
34		* Returns 1 if successful or -1 on error
35		*/
36		int liblnk_data_block_initialize(
37		liblnk_data_block_t **data_block,
38		libcerror_error_t **error )
39	399k	{
40	399k	liblnk_internal_data_block_t *internal_data_block = NULL;
41	399k	static char *function = "liblnk_data_block_initialize";
42
43	399k	if( data_block == NULL )
44	0	{
45	0	libcerror_error_set(
46	0	error,
47	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
48	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
49	0	"%s: invalid data block.",
50	0	function );
51
52	0	return( -1 );
53	0	}
54	399k	if( *data_block != NULL )
55	0	{
56	0	libcerror_error_set(
57	0	error,
58	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
59	0	LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
60	0	"%s: invalid data block value already set.",
61	0	function );
62
63	0	return( -1 );
64	0	}
65	399k	internal_data_block = memory_allocate_structure(
66	399k	liblnk_internal_data_block_t );
67
68	399k	if( internal_data_block == NULL )
69	0	{
70	0	libcerror_error_set(
71	0	error,
72	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
73	0	LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
74	0	"%s: unable to create data block.",
75	0	function );
76
77	0	goto on_error;
78	0	}
79	399k	if( memory_set(
80	399k	internal_data_block,
81	399k	0,
82	399k	sizeof( liblnk_internal_data_block_t ) ) == NULL )
83	0	{
84	0	libcerror_error_set(
85	0	error,
86	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
87	0	LIBCERROR_MEMORY_ERROR_SET_FAILED,
88	0	"%s: unable to clear data block.",
89	0	function );
90
91	0	goto on_error;
92	0	}
93	399k	data_block = (liblnk_data_block_t ) internal_data_block;
94
95	399k	return( 1 );
96
97	0	on_error:
98	0	if( internal_data_block != NULL )
99	0	{
100	0	memory_free(
101	0	internal_data_block );
102	0	}
103	0	return( -1 );
104	399k	}
105
106		/* Frees a data block
107		* Returns 1 if successful or -1 on error
108		*/
109		int liblnk_data_block_free(
110		liblnk_data_block_t **data_block,
111		libcerror_error_t **error )
112	0	{
113	0	static char *function = "liblnk_data_block_free";
114
115	0	if( data_block == NULL )
116	0	{
117	0	libcerror_error_set(
118	0	error,
119	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
120	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
121	0	"%s: invalid data block.",
122	0	function );
123
124	0	return( -1 );
125	0	}
126	0	if( *data_block != NULL )
127	0	{
128	0	*data_block = NULL;
129	0	}
130	0	return( 1 );
131	0	}
132
133		/* Frees a data block
134		* Returns 1 if successful or -1 on error
135		*/
136		int liblnk_internal_data_block_free(
137		liblnk_internal_data_block_t **internal_data_block,
138		libcerror_error_t **error )
139	399k	{
140	399k	static char *function = "liblnk_internal_data_block_free";
141	399k	int result = 1;
142
143	399k	if( internal_data_block == NULL )
144	0	{
145	0	libcerror_error_set(
146	0	error,
147	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
148	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
149	0	"%s: invalid data block.",
150	0	function );
151
152	0	return( -1 );
153	0	}
154	399k	if( *internal_data_block != NULL )
155	399k	{
156	399k	if( ( *internal_data_block )->value != NULL )
157	2.58k	{
158	2.58k	if( ( *internal_data_block )->free_value != NULL )
159	2.58k	{
160	2.58k	if( ( *internal_data_block )->free_value(
161	2.58k	&( ( *internal_data_block )->value ),
162	2.58k	error ) != 1 )
163	0	{
164	0	libcerror_error_set(
165	0	error,
166	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
167	0	LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED,
168	0	"%s: unable to free data block value.",
169	0	function );
170
171	0	result = -1;
172	0	}
173	2.58k	}
174	2.58k	}
175	399k	if( ( *internal_data_block )->data != NULL )
176	399k	{
177	399k	memory_free(
178	399k	( *internal_data_block )->data );
179	399k	}
180	399k	memory_free(
181	399k	*internal_data_block );
182
183	399k	*internal_data_block = NULL;
184	399k	}
185	399k	return( result );
186	399k	}
187
188		/* Sets the data of a data block
189		* Returns 1 if successful or -1 on error
190		*/
191		int liblnk_data_block_set_data(
192		liblnk_data_block_t *data_block,
193		const uint8_t *data,
194		size_t data_size,
195		libcerror_error_t **error )
196	0	{
197	0	liblnk_internal_data_block_t *internal_data_block = NULL;
198	0	static char *function = "liblnk_data_block_set_data";
199
200	0	if( data_block == NULL )
201	0	{
202	0	libcerror_error_set(
203	0	error,
204	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
205	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
206	0	"%s: invalid data block.",
207	0	function );
208
209	0	return( -1 );
210	0	}
211	0	internal_data_block = (liblnk_internal_data_block_t *) data_block;
212
213	0	if( data == NULL )
214	0	{
215	0	libcerror_error_set(
216	0	error,
217	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
218	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
219	0	"%s: invalid data.",
220	0	function );
221
222	0	return( -1 );
223	0	}
224	0	if( data_size > MEMORY_MAXIMUM_ALLOCATION_SIZE )
225	0	{
226	0	libcerror_error_set(
227	0	error,
228	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
229	0	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
230	0	"%s: invalid data size value out of bounds.",
231	0	function );
232
233	0	return( -1 );
234	0	}
235	0	internal_data_block->data = (uint8_t *) memory_allocate(
236	0	sizeof( uint8_t ) * data_size );
237
238	0	if( internal_data_block->data == NULL )
239	0	{
240	0	libcerror_error_set(
241	0	error,
242	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
243	0	LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
244	0	"%s: unable to create data block data.",
245	0	function );
246
247	0	goto on_error;
248	0	}
249	0	internal_data_block->data_size = data_size;
250
251	0	if( memory_copy(
252	0	internal_data_block->data,
253	0	data,
254	0	data_size ) == NULL )
255	0	{
256	0	libcerror_error_set(
257	0	error,
258	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
259	0	LIBCERROR_MEMORY_ERROR_COPY_FAILED,
260	0	"%s: unable to copy data.",
261	0	function );
262
263	0	goto on_error;
264	0	}
265	0	return( 1 );
266
267	0	on_error:
268	0	if( internal_data_block->data != NULL )
269	0	{
270	0	memory_free(
271	0	internal_data_block->data );
272
273	0	internal_data_block->data = NULL;
274	0	}
275	0	internal_data_block->size = 0;
276
277	0	return( -1 );
278	0	}
279
280		/* Reads a data block
281		* Returns 1 if successful or -1 on error
282		*/
283		int liblnk_data_block_read_data(
284		liblnk_data_block_t *data_block,
285		const uint8_t *data,
286		size_t data_size,
287		libcerror_error_t **error )
288	399k	{
289	399k	liblnk_internal_data_block_t *internal_data_block = NULL;
290	399k	static char *function = "liblnk_data_block_read_data";
291
292	399k	if( data_block == NULL )
293	0	{
294	0	libcerror_error_set(
295	0	error,
296	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
297	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
298	0	"%s: invalid data block.",
299	0	function );
300
301	0	return( -1 );
302	0	}
303	399k	internal_data_block = (liblnk_internal_data_block_t *) data_block;
304
305	399k	if( data == NULL )
306	0	{
307	0	libcerror_error_set(
308	0	error,
309	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
310	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
311	0	"%s: invalid data.",
312	0	function );
313
314	0	return( -1 );
315	0	}
316	399k	if( ( data_size < 4 )
317	399k	\|\| ( data_size > (size_t) SSIZE_MAX ) )
318	26	{
319	26	libcerror_error_set(
320	26	error,
321	26	LIBCERROR_ERROR_DOMAIN_RUNTIME,
322	26	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
323	26	"%s: invalid data size value out of bounds.",
324	26	function );
325
326	26	return( -1 );
327	26	}
328		#if defined( HAVE_DEBUG_OUTPUT )
329		if( libcnotify_verbose != 0 )
330		{
331		libcnotify_printf(
332		"%s: data block data:\n",
333		function );
334		libcnotify_print_data(
335		data,
336		data_size,
337		LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
338		}
339		#endif /* defined( HAVE_DEBUG_OUTPUT ) */
340
341	399k	byte_stream_copy_to_uint32_little_endian(
342	399k	data,
343	399k	internal_data_block->signature );
344
345		#if defined( HAVE_DEBUG_OUTPUT )
346		if( libcnotify_verbose != 0 )
347		{
348		libcnotify_printf(
349		"%s: data block signature\t\t\t: 0x%08" PRIx32 "\n",
350		function,
351		internal_data_block->signature );
352
353		if( data_size > 4 )
354		{
355		libcnotify_printf(
356		"%s: data block data:\n",
357		function );
358		libcnotify_print_data(
359		&( data[ 4 ] ),
360		data_size - 4,
361		LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
362		}
363		}
364		#endif /* defined( HAVE_DEBUG_OUTPUT ) */
365
366	399k	return( 1 );
367	399k	}
368
369		/* Reads a data block
370		* Returns the number of bytes read if successful or -1 on error
371		*/
372		int liblnk_data_block_read_file_io_handle(
373		liblnk_data_block_t *data_block,
374		liblnk_io_handle_t *io_handle,
375		libbfio_handle_t *file_io_handle,
376		off64_t file_offset,
377		libcerror_error_t **error )
378	399k	{
379	399k	uint8_t data_block_size_data[ 4 ];
380
381	399k	liblnk_internal_data_block_t *internal_data_block = NULL;
382	399k	static char *function = "liblnk_data_block_read_file_io_handle";
383	399k	ssize_t read_count = 0;
384
385	399k	if( data_block == NULL )
386	0	{
387	0	libcerror_error_set(
388	0	error,
389	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
390	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
391	0	"%s: invalid data block.",
392	0	function );
393
394	0	return( -1 );
395	0	}
396	399k	internal_data_block = (liblnk_internal_data_block_t *) data_block;
397
398	399k	if( internal_data_block->data != NULL )
399	0	{
400	0	libcerror_error_set(
401	0	error,
402	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
403	0	LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
404	0	"%s: invalid data block - data already set.",
405	0	function );
406
407	0	return( -1 );
408	0	}
409	399k	if( io_handle == NULL )
410	0	{
411	0	libcerror_error_set(
412	0	error,
413	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
414	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
415	0	"%s: invalid IO handle.",
416	0	function );
417
418	0	return( -1 );
419	0	}
420		#if defined( HAVE_DEBUG_OUTPUT )
421		if( libcnotify_verbose != 0 )
422		{
423		libcnotify_printf(
424		"%s: reading data block at offset: %" PRIi64 " (0x%08" PRIx64 ")\n",
425		function,
426		file_offset,
427		file_offset );
428		}
429		#endif
430	399k	read_count = libbfio_handle_read_buffer_at_offset(
431	399k	file_io_handle,
432	399k	data_block_size_data,
433	399k	4,
434	399k	file_offset,
435	399k	error );
436
437	399k	if( read_count != (ssize_t) 4 )
438	58	{
439	58	libcerror_error_set(
440	58	error,
441	58	LIBCERROR_ERROR_DOMAIN_IO,
442	58	LIBCERROR_IO_ERROR_READ_FAILED,
443	58	"%s: unable to read data block size at offset: %" PRIi64 " (0x%08" PRIx64 ").",
444	58	function,
445	58	file_offset,
446	58	file_offset );
447
448	58	goto on_error;
449	58	}
450	399k	byte_stream_copy_to_uint32_little_endian(
451	399k	data_block_size_data,
452	399k	internal_data_block->size );
453
454		#if defined( HAVE_DEBUG_OUTPUT )
455		if( libcnotify_verbose != 0 )
456		{
457		libcnotify_printf(
458		"%s: data block size\t\t\t: %" PRIu32 "\n",
459		function,
460		internal_data_block->size );
461		}
462		#endif
463	399k	if( internal_data_block->size > 0 )
464	399k	{
465	399k	if( ( internal_data_block->size < 4 )
466	399k	\|\| ( internal_data_block->size > ( MEMORY_MAXIMUM_ALLOCATION_SIZE + 4 ) ) )
467	48	{
468	48	libcerror_error_set(
469	48	error,
470	48	LIBCERROR_ERROR_DOMAIN_RUNTIME,
471	48	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
472	48	"%s: invalid data block size value out of bounds.",
473	48	function );
474
475	48	goto on_error;
476	48	}
477	399k	internal_data_block->data_size = internal_data_block->size - 4;
478
479	399k	internal_data_block->data = (uint8_t *) memory_allocate(
480	399k	sizeof( uint8_t ) * internal_data_block->data_size );
481
482	399k	if( internal_data_block->data == NULL )
483	0	{
484	0	libcerror_error_set(
485	0	error,
486	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
487	0	LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
488	0	"%s: unable to create data block data.",
489	0	function );
490
491	0	goto on_error;
492	0	}
493	399k	if( (off64_t) internal_data_block->size > (off64_t) ( io_handle->file_size - file_offset ) )
494	50	{
495	50	libcerror_error_set(
496	50	error,
497	50	LIBCERROR_ERROR_DOMAIN_RUNTIME,
498	50	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
499	50	"%s: invalid data block size value exceeds file size.",
500	50	function );
501
502	50	goto on_error;
503	50	}
504	399k	read_count = libbfio_handle_read_buffer(
505	399k	file_io_handle,
506	399k	internal_data_block->data,
507	399k	internal_data_block->data_size,
508	399k	error );
509
510	399k	if( read_count != (ssize_t) internal_data_block->data_size )
511	0	{
512	0	libcerror_error_set(
513	0	error,
514	0	LIBCERROR_ERROR_DOMAIN_IO,
515	0	LIBCERROR_IO_ERROR_READ_FAILED,
516	0	"%s: unable to read data block data.",
517	0	function );
518
519	0	goto on_error;
520	0	}
521	399k	if( liblnk_data_block_read_data(
522	399k	data_block,
523	399k	internal_data_block->data,
524	399k	internal_data_block->data_size,
525	399k	error ) != 1 )
526	26	{
527	26	libcerror_error_set(
528	26	error,
529	26	LIBCERROR_ERROR_DOMAIN_IO,
530	26	LIBCERROR_IO_ERROR_READ_FAILED,
531	26	"%s: unable to read data block.",
532	26	function );
533
534	26	goto on_error;
535	26	}
536	399k	}
537	399k	internal_data_block->ascii_codepage = io_handle->ascii_codepage;
538
539	399k	return( 1 );
540
541	182	on_error:
542	182	if( internal_data_block->data != NULL )
543	76	{
544	76	memory_free(
545	76	internal_data_block->data );
546
547	76	internal_data_block->data = NULL;
548	76	}
549	182	internal_data_block->size = 0;
550
551	182	return( -1 );
552	399k	}
553
554		/* Retrieves the size
555		* Returns 1 if successful or -1 on error
556		*/
557		int liblnk_internal_data_block_get_size(
558		liblnk_internal_data_block_t *internal_data_block,
559		uint32_t *size,
560		libcerror_error_t **error )
561	399k	{
562	399k	static char *function = "liblnk_internal_data_block_get_size";
563
564	399k	if( internal_data_block == NULL )
565	0	{
566	0	libcerror_error_set(
567	0	error,
568	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
569	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
570	0	"%s: invalid data block.",
571	0	function );
572
573	0	return( -1 );
574	0	}
575	399k	if( size == NULL )
576	0	{
577	0	libcerror_error_set(
578	0	error,
579	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
580	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
581	0	"%s: invalid size.",
582	0	function );
583
584	0	return( -1 );
585	0	}
586	399k	*size = internal_data_block->size;
587
588	399k	return( 1 );
589	399k	}
590
591		/* Retrieves the signature
592		* Returns 1 if successful or -1 on error
593		*/
594		int liblnk_data_block_get_signature(
595		liblnk_data_block_t *data_block,
596		uint32_t *signature,
597		libcerror_error_t **error )
598	399k	{
599	399k	liblnk_internal_data_block_t *internal_data_block = NULL;
600	399k	static char *function = "liblnk_data_block_get_signature";
601
602	399k	if( data_block == NULL )
603	0	{
604	0	libcerror_error_set(
605	0	error,
606	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
607	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
608	0	"%s: invalid data block.",
609	0	function );
610
611	0	return( -1 );
612	0	}
613	399k	internal_data_block = (liblnk_internal_data_block_t *) data_block;
614
615	399k	if( internal_data_block->data_size < 4 )
616	0	{
617	0	libcerror_error_set(
618	0	error,
619	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
620	0	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
621	0	"%s: invalid data block - data size value out of bounds.",
622	0	function );
623
624	0	return( -1 );
625	0	}
626	399k	if( signature == NULL )
627	0	{
628	0	libcerror_error_set(
629	0	error,
630	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
631	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
632	0	"%s: invalid signature.",
633	0	function );
634
635	0	return( -1 );
636	0	}
637	399k	*signature = internal_data_block->signature;
638
639	399k	return( 1 );
640	399k	}
641
642		/* Retrieves the data block data size
643		* Returns 1 if successful or -1 on error
644		*/
645		int liblnk_data_block_get_data_size(
646		liblnk_data_block_t *data_block,
647		size_t *data_size,
648		libcerror_error_t **error )
649	0	{
650	0	liblnk_internal_data_block_t *internal_data_block = NULL;
651	0	static char *function = "liblnk_data_block_get_data_size";
652
653	0	if( data_block == NULL )
654	0	{
655	0	libcerror_error_set(
656	0	error,
657	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
658	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
659	0	"%s: invalid data block.",
660	0	function );
661
662	0	return( -1 );
663	0	}
664	0	internal_data_block = (liblnk_internal_data_block_t *) data_block;
665
666	0	if( internal_data_block->data_size < 4 )
667	0	{
668	0	libcerror_error_set(
669	0	error,
670	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
671	0	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
672	0	"%s: invalid data block - data size value out of bounds.",
673	0	function );
674
675	0	return( -1 );
676	0	}
677	0	if( data_size == NULL )
678	0	{
679	0	libcerror_error_set(
680	0	error,
681	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
682	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
683	0	"%s: invalid data size.",
684	0	function );
685
686	0	return( -1 );
687	0	}
688	0	*data_size = (size_t) internal_data_block->data_size - 4;
689
690	0	return( 1 );
691	0	}
692
693		/* Copies the data block data to the buffer
694		* Returns 1 if successful or -1 on error
695		*/
696		int liblnk_data_block_copy_data(
697		liblnk_data_block_t *data_block,
698		uint8_t *data,
699		size_t data_size,
700		libcerror_error_t **error )
701	0	{
702	0	liblnk_internal_data_block_t *internal_data_block = NULL;
703	0	static char *function = "liblnk_data_block_copy_data";
704
705	0	if( data_block == NULL )
706	0	{
707	0	libcerror_error_set(
708	0	error,
709	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
710	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
711	0	"%s: invalid data block.",
712	0	function );
713
714	0	return( -1 );
715	0	}
716	0	internal_data_block = (liblnk_internal_data_block_t *) data_block;
717
718	0	if( internal_data_block->data_size < 4 )
719	0	{
720	0	libcerror_error_set(
721	0	error,
722	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
723	0	LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS,
724	0	"%s: invalid data block - data size value out of bounds.",
725	0	function );
726
727	0	return( -1 );
728	0	}
729	0	if( data == NULL )
730	0	{
731	0	libcerror_error_set(
732	0	error,
733	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
734	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
735	0	"%s: invalid data.",
736	0	function );
737
738	0	return( -1 );
739	0	}
740	0	if( ( data_size < (size_t) ( internal_data_block->data_size - 4 ) )
741	0	\|\| ( data_size > (size_t) SSIZE_MAX ) )
742	0	{
743	0	libcerror_error_set(
744	0	error,
745	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
746	0	LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
747	0	"%s: invalid data size value out of bounds.",
748	0	function );
749
750	0	return( -1 );
751	0	}
752	0	if( memory_copy(
753	0	data,
754	0	&( internal_data_block->data[ 4 ] ),
755	0	internal_data_block->data_size - 4 ) == NULL )
756	0	{
757	0	libcerror_error_set(
758	0	error,
759	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
760	0	LIBCERROR_MEMORY_ERROR_COPY_FAILED,
761	0	"%s: unable to copy data block data.",
762	0	function );
763
764	0	return( -1 );
765	0	}
766	0	return( 1 );
767	0	}
768