/src/libmodi/libmodi/libmodi_udif_resource_file.c

Source (jump to first uncovered line)
/*
 * Universal Disk Image Format (UDIF) resource file functions
 *
 * Copyright (C) 2012-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 "libmodi_io_handle.h"
#include "libmodi_libbfio.h"
#include "libmodi_libcerror.h"
#include "libmodi_libcnotify.h"
#include "libmodi_udif_resource_file.h"

#include "modi_udif_resource_file.h"

/* Creates a resource file
 * Make sure the value resource_file is referencing, is set to NULL
 * Returns 1 if successful or -1 on error
 */
int libmodi_udif_resource_file_initialize(
     libmodi_udif_resource_file_t **resource_file,
     libcerror_error_t **error )
{
  static char *function = "libmodi_udif_resource_file_initialize";

  if( resource_file == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid resource file.",
     function );

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

    return( -1 );
  }
  *resource_file = memory_allocate_structure(
                    libmodi_udif_resource_file_t );

  if( *resource_file == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
     "%s: unable to create resource file.",
     function );

    goto on_error;
  }
  if( memory_set(
       *resource_file,
       0,
       sizeof( libmodi_udif_resource_file_t ) ) == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_MEMORY,
     LIBCERROR_MEMORY_ERROR_SET_FAILED,
     "%s: unable to clear resource file.",
     function );

    goto on_error;
  }
  return( 1 );

on_error:
  if( *resource_file != NULL )
  {
    memory_free(
     *resource_file );

    *resource_file = NULL;
  }
  return( -1 );
}

/* Frees a resource file
 * Returns 1 if successful or -1 on error
 */
int libmodi_udif_resource_file_free(
     libmodi_udif_resource_file_t **resource_file,
     libcerror_error_t **error )
{
  static char *function = "libmodi_udif_resource_file_free";

  if( resource_file == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid resource file.",
     function );

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

    *resource_file = NULL;
  }
  return( 1 );
}

/* Reads a resource file
 * Returns 1 if successful, 0 if the signature does not match or -1 on error
 */
int libmodi_udif_resource_file_read_data(
     libmodi_udif_resource_file_t *resource_file,
     const uint8_t *data,
     size_t data_size,
     libcerror_error_t **error )
{
  static char *function       = "libmodi_udif_resource_file_read_data";
  uint32_t number_of_segments = 0;

#if defined( HAVE_DEBUG_OUTPUT )
  uint64_t value_64bit        = 0;
  uint32_t value_32bit        = 0;
#endif

  if( resource_file == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid resource file.",
     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 < sizeof( modi_udif_resource_file_t ) )
   || ( 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 defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: resource file data:\n",
     function );
    libcnotify_print_data(
     data,
     sizeof( modi_udif_resource_file_t ),
     LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
  }
#endif
  if( memory_compare(
       ( (modi_udif_resource_file_t *) data )->signature,
       modi_udif_resource_file_signature,
       4 ) != 0 )
  {
    return( 0 );
  }
  byte_stream_copy_to_uint64_big_endian(
   ( (modi_udif_resource_file_t *) data )->data_fork_offset,
   resource_file->data_fork_offset );

  byte_stream_copy_to_uint64_big_endian(
   ( (modi_udif_resource_file_t *) data )->data_fork_size,
   resource_file->data_fork_size );

  byte_stream_copy_to_uint64_big_endian(
   ( (modi_udif_resource_file_t *) data )->resource_fork_offset,
   resource_file->resource_fork_offset );

  byte_stream_copy_to_uint64_big_endian(
   ( (modi_udif_resource_file_t *) data )->resource_fork_size,
   resource_file->resource_fork_size );

  byte_stream_copy_to_uint32_big_endian(
   ( (modi_udif_resource_file_t *) data )->number_of_segments,
   number_of_segments );

  byte_stream_copy_to_uint64_big_endian(
   ( (modi_udif_resource_file_t *) data )->xml_plist_offset,
   resource_file->xml_plist_offset );

  byte_stream_copy_to_uint64_big_endian(
   ( (modi_udif_resource_file_t *) data )->xml_plist_size,
   resource_file->xml_plist_size );

  byte_stream_copy_to_uint32_big_endian(
   ( (modi_udif_resource_file_t *) data )->number_of_sectors,
   resource_file->number_of_sectors );

#if defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: signature\t\t\t\t: %c%c%c%c\n",
     function,
     ( (modi_udif_resource_file_t *) data )->signature[ 0 ],
     ( (modi_udif_resource_file_t *) data )->signature[ 1 ],
     ( (modi_udif_resource_file_t *) data )->signature[ 2 ],
     ( (modi_udif_resource_file_t *) data )->signature[ 3 ] );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->format_version,
     value_32bit );
    libcnotify_printf(
     "%s: format version\t\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->size,
     value_32bit );
    libcnotify_printf(
     "%s: size\t\t\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->flags,
     value_32bit );
    libcnotify_printf(
     "%s: flags\t\t\t\t: 0x%08" PRIx32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint64_big_endian(
     ( (modi_udif_resource_file_t *) data )->unknown1,
     value_64bit );
    libcnotify_printf(
     "%s: unknown1\t\t\t\t: 0x%08" PRIx64 "\n",
     function,
     value_64bit );

    libcnotify_printf(
     "%s: data fork offset\t\t\t: 0x%08" PRIx64 "\n",
     function,
     resource_file->data_fork_offset );

    libcnotify_printf(
     "%s: data fork size\t\t\t: %" PRIu64 "\n",
     function,
     resource_file->data_fork_size );

    libcnotify_printf(
     "%s: resource fork offset\t\t: 0x%08" PRIx64 "\n",
     function,
     resource_file->resource_fork_offset );

    libcnotify_printf(
     "%s: resource fork size\t\t: %" PRIu64 "\n",
     function,
     resource_file->resource_fork_size );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->unknown2,
     value_32bit );
    libcnotify_printf(
     "%s: unknown2\t\t\t\t: 0x%08" PRIx32 "\n",
     function,
     value_32bit );

    libcnotify_printf(
     "%s: number of segments\t\t: %" PRIu32 "\n",
     function,
     number_of_segments );

    libcnotify_printf(
     "%s: segment identifier:\n",
     function );
    libcnotify_print_data(
     ( (modi_udif_resource_file_t *) data )->segment_identifier,
     16,
     0 );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->data_checksum_type,
     value_32bit );
    libcnotify_printf(
     "%s: data checksum type\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->data_checksum_size,
     value_32bit );
    libcnotify_printf(
     "%s: data checksum size\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    libcnotify_printf(
     "%s: data checksum:\n",
     function );
    libcnotify_print_data(
     ( (modi_udif_resource_file_t *) data )->data_checksum,
     128,
     LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );

    libcnotify_printf(
     "%s: XML plist offset\t\t\t: 0x%08" PRIx64 "\n",
     function,
     resource_file->xml_plist_offset );

    libcnotify_printf(
     "%s: XML plist size\t\t\t: %" PRIu64 "\n",
     function,
     resource_file->xml_plist_size );

    libcnotify_printf(
     "%s: unknown3:\n",
     function );
    libcnotify_print_data(
     ( (modi_udif_resource_file_t *) data )->unknown3,
     120,
     LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->master_checksum_type,
     value_32bit );
    libcnotify_printf(
     "%s: master checksum type\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->master_checksum_size,
     value_32bit );
    libcnotify_printf(
     "%s: master checksum size\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    libcnotify_printf(
     "%s: master checksum data:\n",
     function );
    libcnotify_print_data(
     ( (modi_udif_resource_file_t *) data )->master_checksum,
     128,
     LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->image_type,
     value_32bit );
    libcnotify_printf(
     "%s: image type\t\t\t: %" PRIu32 "\n",
     function,
     value_32bit );

    libcnotify_printf(
     "%s: number of sectors\t\t\t: %" PRIu32 "\n",
     function,
     resource_file->number_of_sectors );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->unknown5,
     value_32bit );
    libcnotify_printf(
     "%s: unknown5\t\t\t\t: 0x%08" PRIx32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->unknown6,
     value_32bit );
    libcnotify_printf(
     "%s: unknown6\t\t\t\t: 0x%08" PRIx32 "\n",
     function,
     value_32bit );

    byte_stream_copy_to_uint32_big_endian(
     ( (modi_udif_resource_file_t *) data )->unknown7,
     value_32bit );
    libcnotify_printf(
     "%s: unknown7\t\t\t\t: 0x%08" PRIx32 "\n",
     function,
     value_32bit );

    libcnotify_printf(
     "\n" );
  }
#endif /* defined( HAVE_DEBUG_OUTPUT ) */

  if( number_of_segments > 1 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_RUNTIME,
     LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
     "%s: unsupported number of segments.",
     function );

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

/* Reads a resource file
 * Returns 1 if successful, 0 if the signature does not match or -1 on error
 */
int libmodi_udif_resource_file_read_file_io_handle(
     libmodi_udif_resource_file_t *resource_file,
     libbfio_handle_t *file_io_handle,
     off64_t offset,
     libcerror_error_t **error )
{
  uint8_t *resource_file_data = NULL;
  static char *function       = "libmodi_udif_resource_file_read_file_io_handle";
  size_t read_size            = 512;
  ssize_t read_count          = 0;
  int result                  = 0;

  if( resource_file == NULL )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
     LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
     "%s: invalid resource file.",
     function );

    return( -1 );
  }
  resource_file_data = (uint8_t *) memory_allocate(
                                    read_size );

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

    goto on_error;
  }
#if defined( HAVE_DEBUG_OUTPUT )
  if( libcnotify_verbose != 0 )
  {
    libcnotify_printf(
     "%s: reading resource file at offset: %" PRIi64 " (0x%08" PRIx64 ").\n",
     function,
     offset,
     offset );
  }
#endif
  read_count = libbfio_handle_read_buffer_at_offset(
                file_io_handle,
                resource_file_data,
                read_size,
                offset,
                error );

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

    goto on_error;
  }
  result = libmodi_udif_resource_file_read_data(
            resource_file,
            resource_file_data,
            read_size,
            error );

  if( result == -1 )
  {
    libcerror_error_set(
     error,
     LIBCERROR_ERROR_DOMAIN_IO,
     LIBCERROR_IO_ERROR_READ_FAILED,
     "%s: unable to read resource file.",
     function );

    goto on_error;
  }
  memory_free(
   resource_file_data );

  resource_file_data = NULL;

  return( result );

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


Coverage Report

Created: 2024-06-12 07:07

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Universal Disk Image Format (UDIF) resource file functions
3		*
4		* Copyright (C) 2012-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 "libmodi_io_handle.h"
28		#include "libmodi_libbfio.h"
29		#include "libmodi_libcerror.h"
30		#include "libmodi_libcnotify.h"
31		#include "libmodi_udif_resource_file.h"
32
33		#include "modi_udif_resource_file.h"
34
35		/* Creates a resource file
36		* Make sure the value resource_file is referencing, is set to NULL
37		* Returns 1 if successful or -1 on error
38		*/
39		int libmodi_udif_resource_file_initialize(
40		libmodi_udif_resource_file_t **resource_file,
41		libcerror_error_t **error )
42	1.68k	{
43	1.68k	static char *function = "libmodi_udif_resource_file_initialize";
44
45	1.68k	if( resource_file == NULL )
46	0	{
47	0	libcerror_error_set(
48	0	error,
49	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
50	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
51	0	"%s: invalid resource file.",
52	0	function );
53
54	0	return( -1 );
55	0	}
56	1.68k	if( *resource_file != NULL )
57	0	{
58	0	libcerror_error_set(
59	0	error,
60	0	LIBCERROR_ERROR_DOMAIN_RUNTIME,
61	0	LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET,
62	0	"%s: invalid resource file value already set.",
63	0	function );
64
65	0	return( -1 );
66	0	}
67	1.68k	*resource_file = memory_allocate_structure(
68	1.68k	libmodi_udif_resource_file_t );
69
70	1.68k	if( *resource_file == NULL )
71	0	{
72	0	libcerror_error_set(
73	0	error,
74	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
75	0	LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
76	0	"%s: unable to create resource file.",
77	0	function );
78
79	0	goto on_error;
80	0	}
81	1.68k	if( memory_set(
82	1.68k	*resource_file,
83	1.68k	0,
84	1.68k	sizeof( libmodi_udif_resource_file_t ) ) == NULL )
85	0	{
86	0	libcerror_error_set(
87	0	error,
88	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
89	0	LIBCERROR_MEMORY_ERROR_SET_FAILED,
90	0	"%s: unable to clear resource file.",
91	0	function );
92
93	0	goto on_error;
94	0	}
95	1.68k	return( 1 );
96
97	0	on_error:
98	0	if( *resource_file != NULL )
99	0	{
100	0	memory_free(
101	0	*resource_file );
102
103	0	*resource_file = NULL;
104	0	}
105	0	return( -1 );
106	1.68k	}
107
108		/* Frees a resource file
109		* Returns 1 if successful or -1 on error
110		*/
111		int libmodi_udif_resource_file_free(
112		libmodi_udif_resource_file_t **resource_file,
113		libcerror_error_t **error )
114	1.68k	{
115	1.68k	static char *function = "libmodi_udif_resource_file_free";
116
117	1.68k	if( resource_file == NULL )
118	0	{
119	0	libcerror_error_set(
120	0	error,
121	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
122	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
123	0	"%s: invalid resource file.",
124	0	function );
125
126	0	return( -1 );
127	0	}
128	1.68k	if( *resource_file != NULL )
129	1.68k	{
130	1.68k	memory_free(
131	1.68k	*resource_file );
132
133	1.68k	*resource_file = NULL;
134	1.68k	}
135	1.68k	return( 1 );
136	1.68k	}
137
138		/* Reads a resource file
139		* Returns 1 if successful, 0 if the signature does not match or -1 on error
140		*/
141		int libmodi_udif_resource_file_read_data(
142		libmodi_udif_resource_file_t *resource_file,
143		const uint8_t *data,
144		size_t data_size,
145		libcerror_error_t **error )
146	1.68k	{
147	1.68k	static char *function = "libmodi_udif_resource_file_read_data";
148	1.68k	uint32_t number_of_segments = 0;
149
150		#if defined( HAVE_DEBUG_OUTPUT )
151		uint64_t value_64bit = 0;
152		uint32_t value_32bit = 0;
153		#endif
154
155	1.68k	if( resource_file == NULL )
156	0	{
157	0	libcerror_error_set(
158	0	error,
159	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
160	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
161	0	"%s: invalid resource file.",
162	0	function );
163
164	0	return( -1 );
165	0	}
166	1.68k	if( data == NULL )
167	0	{
168	0	libcerror_error_set(
169	0	error,
170	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
171	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
172	0	"%s: invalid data.",
173	0	function );
174
175	0	return( -1 );
176	0	}
177	1.68k	if( ( data_size < sizeof( modi_udif_resource_file_t ) )
178	1.68k	\|\| ( data_size > (size_t) SSIZE_MAX ) )
179	0	{
180	0	libcerror_error_set(
181	0	error,
182	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
183	0	LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS,
184	0	"%s: invalid data size value out of bounds.",
185	0	function );
186
187	0	return( -1 );
188	0	}
189		#if defined( HAVE_DEBUG_OUTPUT )
190		if( libcnotify_verbose != 0 )
191		{
192		libcnotify_printf(
193		"%s: resource file data:\n",
194		function );
195		libcnotify_print_data(
196		data,
197		sizeof( modi_udif_resource_file_t ),
198		LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
199		}
200		#endif
201	1.68k	if( memory_compare(
202	1.68k	( (modi_udif_resource_file_t *) data )->signature,
203	1.68k	modi_udif_resource_file_signature,
204	1.68k	4 ) != 0 )
205	478	{
206	478	return( 0 );
207	478	}
208	1.20k	byte_stream_copy_to_uint64_big_endian(
209	1.20k	( (modi_udif_resource_file_t *) data )->data_fork_offset,
210	1.20k	resource_file->data_fork_offset );
211
212	1.20k	byte_stream_copy_to_uint64_big_endian(
213	1.20k	( (modi_udif_resource_file_t *) data )->data_fork_size,
214	1.20k	resource_file->data_fork_size );
215
216	1.20k	byte_stream_copy_to_uint64_big_endian(
217	1.20k	( (modi_udif_resource_file_t *) data )->resource_fork_offset,
218	1.20k	resource_file->resource_fork_offset );
219
220	1.20k	byte_stream_copy_to_uint64_big_endian(
221	1.20k	( (modi_udif_resource_file_t *) data )->resource_fork_size,
222	1.20k	resource_file->resource_fork_size );
223
224	1.20k	byte_stream_copy_to_uint32_big_endian(
225	1.20k	( (modi_udif_resource_file_t *) data )->number_of_segments,
226	1.20k	number_of_segments );
227
228	1.20k	byte_stream_copy_to_uint64_big_endian(
229	1.20k	( (modi_udif_resource_file_t *) data )->xml_plist_offset,
230	1.20k	resource_file->xml_plist_offset );
231
232	1.20k	byte_stream_copy_to_uint64_big_endian(
233	1.20k	( (modi_udif_resource_file_t *) data )->xml_plist_size,
234	1.20k	resource_file->xml_plist_size );
235
236	1.20k	byte_stream_copy_to_uint32_big_endian(
237	1.20k	( (modi_udif_resource_file_t *) data )->number_of_sectors,
238	1.20k	resource_file->number_of_sectors );
239
240		#if defined( HAVE_DEBUG_OUTPUT )
241		if( libcnotify_verbose != 0 )
242		{
243		libcnotify_printf(
244		"%s: signature\t\t\t\t: %c%c%c%c\n",
245		function,
246		( (modi_udif_resource_file_t *) data )->signature[ 0 ],
247		( (modi_udif_resource_file_t *) data )->signature[ 1 ],
248		( (modi_udif_resource_file_t *) data )->signature[ 2 ],
249		( (modi_udif_resource_file_t *) data )->signature[ 3 ] );
250
251		byte_stream_copy_to_uint32_big_endian(
252		( (modi_udif_resource_file_t *) data )->format_version,
253		value_32bit );
254		libcnotify_printf(
255		"%s: format version\t\t\t: %" PRIu32 "\n",
256		function,
257		value_32bit );
258
259		byte_stream_copy_to_uint32_big_endian(
260		( (modi_udif_resource_file_t *) data )->size,
261		value_32bit );
262		libcnotify_printf(
263		"%s: size\t\t\t\t: %" PRIu32 "\n",
264		function,
265		value_32bit );
266
267		byte_stream_copy_to_uint32_big_endian(
268		( (modi_udif_resource_file_t *) data )->flags,
269		value_32bit );
270		libcnotify_printf(
271		"%s: flags\t\t\t\t: 0x%08" PRIx32 "\n",
272		function,
273		value_32bit );
274
275		byte_stream_copy_to_uint64_big_endian(
276		( (modi_udif_resource_file_t *) data )->unknown1,
277		value_64bit );
278		libcnotify_printf(
279		"%s: unknown1\t\t\t\t: 0x%08" PRIx64 "\n",
280		function,
281		value_64bit );
282
283		libcnotify_printf(
284		"%s: data fork offset\t\t\t: 0x%08" PRIx64 "\n",
285		function,
286		resource_file->data_fork_offset );
287
288		libcnotify_printf(
289		"%s: data fork size\t\t\t: %" PRIu64 "\n",
290		function,
291		resource_file->data_fork_size );
292
293		libcnotify_printf(
294		"%s: resource fork offset\t\t: 0x%08" PRIx64 "\n",
295		function,
296		resource_file->resource_fork_offset );
297
298		libcnotify_printf(
299		"%s: resource fork size\t\t: %" PRIu64 "\n",
300		function,
301		resource_file->resource_fork_size );
302
303		byte_stream_copy_to_uint32_big_endian(
304		( (modi_udif_resource_file_t *) data )->unknown2,
305		value_32bit );
306		libcnotify_printf(
307		"%s: unknown2\t\t\t\t: 0x%08" PRIx32 "\n",
308		function,
309		value_32bit );
310
311		libcnotify_printf(
312		"%s: number of segments\t\t: %" PRIu32 "\n",
313		function,
314		number_of_segments );
315
316		libcnotify_printf(
317		"%s: segment identifier:\n",
318		function );
319		libcnotify_print_data(
320		( (modi_udif_resource_file_t *) data )->segment_identifier,
321		16,
322		0 );
323
324		byte_stream_copy_to_uint32_big_endian(
325		( (modi_udif_resource_file_t *) data )->data_checksum_type,
326		value_32bit );
327		libcnotify_printf(
328		"%s: data checksum type\t\t: %" PRIu32 "\n",
329		function,
330		value_32bit );
331
332		byte_stream_copy_to_uint32_big_endian(
333		( (modi_udif_resource_file_t *) data )->data_checksum_size,
334		value_32bit );
335		libcnotify_printf(
336		"%s: data checksum size\t\t: %" PRIu32 "\n",
337		function,
338		value_32bit );
339
340		libcnotify_printf(
341		"%s: data checksum:\n",
342		function );
343		libcnotify_print_data(
344		( (modi_udif_resource_file_t *) data )->data_checksum,
345		128,
346		LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
347
348		libcnotify_printf(
349		"%s: XML plist offset\t\t\t: 0x%08" PRIx64 "\n",
350		function,
351		resource_file->xml_plist_offset );
352
353		libcnotify_printf(
354		"%s: XML plist size\t\t\t: %" PRIu64 "\n",
355		function,
356		resource_file->xml_plist_size );
357
358		libcnotify_printf(
359		"%s: unknown3:\n",
360		function );
361		libcnotify_print_data(
362		( (modi_udif_resource_file_t *) data )->unknown3,
363		120,
364		LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
365
366		byte_stream_copy_to_uint32_big_endian(
367		( (modi_udif_resource_file_t *) data )->master_checksum_type,
368		value_32bit );
369		libcnotify_printf(
370		"%s: master checksum type\t\t: %" PRIu32 "\n",
371		function,
372		value_32bit );
373
374		byte_stream_copy_to_uint32_big_endian(
375		( (modi_udif_resource_file_t *) data )->master_checksum_size,
376		value_32bit );
377		libcnotify_printf(
378		"%s: master checksum size\t\t: %" PRIu32 "\n",
379		function,
380		value_32bit );
381
382		libcnotify_printf(
383		"%s: master checksum data:\n",
384		function );
385		libcnotify_print_data(
386		( (modi_udif_resource_file_t *) data )->master_checksum,
387		128,
388		LIBCNOTIFY_PRINT_DATA_FLAG_GROUP_DATA );
389
390		byte_stream_copy_to_uint32_big_endian(
391		( (modi_udif_resource_file_t *) data )->image_type,
392		value_32bit );
393		libcnotify_printf(
394		"%s: image type\t\t\t: %" PRIu32 "\n",
395		function,
396		value_32bit );
397
398		libcnotify_printf(
399		"%s: number of sectors\t\t\t: %" PRIu32 "\n",
400		function,
401		resource_file->number_of_sectors );
402
403		byte_stream_copy_to_uint32_big_endian(
404		( (modi_udif_resource_file_t *) data )->unknown5,
405		value_32bit );
406		libcnotify_printf(
407		"%s: unknown5\t\t\t\t: 0x%08" PRIx32 "\n",
408		function,
409		value_32bit );
410
411		byte_stream_copy_to_uint32_big_endian(
412		( (modi_udif_resource_file_t *) data )->unknown6,
413		value_32bit );
414		libcnotify_printf(
415		"%s: unknown6\t\t\t\t: 0x%08" PRIx32 "\n",
416		function,
417		value_32bit );
418
419		byte_stream_copy_to_uint32_big_endian(
420		( (modi_udif_resource_file_t *) data )->unknown7,
421		value_32bit );
422		libcnotify_printf(
423		"%s: unknown7\t\t\t\t: 0x%08" PRIx32 "\n",
424		function,
425		value_32bit );
426
427		libcnotify_printf(
428		"\n" );
429		}
430		#endif /* defined( HAVE_DEBUG_OUTPUT ) */
431
432	1.20k	if( number_of_segments > 1 )
433	41	{
434	41	libcerror_error_set(
435	41	error,
436	41	LIBCERROR_ERROR_DOMAIN_RUNTIME,
437	41	LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE,
438	41	"%s: unsupported number of segments.",
439	41	function );
440
441	41	return( -1 );
442	41	}
443	1.16k	return( 1 );
444	1.20k	}
445
446		/* Reads a resource file
447		* Returns 1 if successful, 0 if the signature does not match or -1 on error
448		*/
449		int libmodi_udif_resource_file_read_file_io_handle(
450		libmodi_udif_resource_file_t *resource_file,
451		libbfio_handle_t *file_io_handle,
452		off64_t offset,
453		libcerror_error_t **error )
454	1.68k	{
455	1.68k	uint8_t *resource_file_data = NULL;
456	1.68k	static char *function = "libmodi_udif_resource_file_read_file_io_handle";
457	1.68k	size_t read_size = 512;
458	1.68k	ssize_t read_count = 0;
459	1.68k	int result = 0;
460
461	1.68k	if( resource_file == NULL )
462	0	{
463	0	libcerror_error_set(
464	0	error,
465	0	LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
466	0	LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
467	0	"%s: invalid resource file.",
468	0	function );
469
470	0	return( -1 );
471	0	}
472	1.68k	resource_file_data = (uint8_t *) memory_allocate(
473	1.68k	read_size );
474
475	1.68k	if( resource_file_data == NULL )
476	0	{
477	0	libcerror_error_set(
478	0	error,
479	0	LIBCERROR_ERROR_DOMAIN_MEMORY,
480	0	LIBCERROR_MEMORY_ERROR_INSUFFICIENT,
481	0	"%s: unable to create resource file data.",
482	0	function );
483
484	0	goto on_error;
485	0	}
486		#if defined( HAVE_DEBUG_OUTPUT )
487		if( libcnotify_verbose != 0 )
488		{
489		libcnotify_printf(
490		"%s: reading resource file at offset: %" PRIi64 " (0x%08" PRIx64 ").\n",
491		function,
492		offset,
493		offset );
494		}
495		#endif
496	1.68k	read_count = libbfio_handle_read_buffer_at_offset(
497	1.68k	file_io_handle,
498	1.68k	resource_file_data,
499	1.68k	read_size,
500	1.68k	offset,
501	1.68k	error );
502
503	1.68k	if( read_count != (ssize_t) read_size )
504	0	{
505	0	libcerror_error_set(
506	0	error,
507	0	LIBCERROR_ERROR_DOMAIN_IO,
508	0	LIBCERROR_IO_ERROR_READ_FAILED,
509	0	"%s: unable to read resource file data at offset: %" PRIi64 " (0x%08" PRIx64 ").",
510	0	function,
511	0	offset,
512	0	offset );
513
514	0	goto on_error;
515	0	}
516	1.68k	result = libmodi_udif_resource_file_read_data(
517	1.68k	resource_file,
518	1.68k	resource_file_data,
519	1.68k	read_size,
520	1.68k	error );
521
522	1.68k	if( result == -1 )
523	41	{
524	41	libcerror_error_set(
525	41	error,
526	41	LIBCERROR_ERROR_DOMAIN_IO,
527	41	LIBCERROR_IO_ERROR_READ_FAILED,
528	41	"%s: unable to read resource file.",
529	41	function );
530
531	41	goto on_error;
532	41	}
533	1.64k	memory_free(
534	1.64k	resource_file_data );
535
536	1.64k	resource_file_data = NULL;
537
538	1.64k	return( result );
539
540	41	on_error:
541	41	if( resource_file_data != NULL )
542	41	{
543	41	memory_free(
544	41	resource_file_data );
545	41	}
546	41	return( -1 );
547	1.68k	}
548