libewf_internal_handle.c

sleuthit-2.09 一个磁盘的工具集

/*
 * libewf handle
 *
 * Copyright (c) 2006-2007, Joachim Metz <[e-mail]>,
 * Hoffmann Investigations. All rights reserved.
 *
 * Refer to AUTHORS for acknowledgements.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 * - Neither the name of the creator, related organisations, nor the names of
 *   its contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 * - All advertising materials mentioning features or use of this software
 *   must acknowledge the contribution by people stated in the acknowledgements.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER, COMPANY AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "libewf_includes.h"

#include <time.h>

#include <libewf/libewf_definitions.h>

#include "libewf_common.h"
#include "libewf_notify.h"
#include "libewf_internal_handle.h"
#include "libewf_string.h"

#include "ewf_crc.h"
#include "ewf_compress.h"
#include "ewf_data.h"
#include "ewf_definitions.h"
#include "ewf_file_header.h"

/* Allocates memory for a new handle struct
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_INTERNAL_HANDLE *libewf_internal_handle_alloc( uint16_t segment_amount, uint8_t flags )
{
	LIBEWF_INTERNAL_HANDLE *internal_handle = NULL;

	if( ( flags != LIBEWF_OPEN_READ ) && ( flags != LIBEWF_OPEN_WRITE ) && ( flags != LIBEWF_OPEN_READ_WRITE ) )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_alloc: invalid flags.\n" );

		return( NULL );
	}
	internal_handle = (LIBEWF_INTERNAL_HANDLE *) libewf_common_alloc( LIBEWF_INTERNAL_HANDLE_SIZE );

	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_alloc: unable to allocate handle.\n" );

		return( NULL );
	}
	internal_handle->media                     = NULL;
	internal_handle->read                      = NULL;
	internal_handle->write                     = NULL;
	internal_handle->segment_table             = NULL;
	internal_handle->offset_table              = NULL;
	internal_handle->secondary_offset_table    = NULL;
	internal_handle->chunk_cache               = NULL;
	internal_handle->header                    = NULL;
	internal_handle->header_size               = 0;
	internal_handle->header2                   = NULL;
	internal_handle->header2_size              = 0;
	internal_handle->xheader                   = NULL;
	internal_handle->xheader_size              = 0;
	internal_handle->xhash                     = NULL;
	internal_handle->xhash_size                = 0;
	internal_handle->header_values             = NULL;
	internal_handle->hash_values               = NULL;
	internal_handle->stored_md5_hash           = NULL;
	internal_handle->calculated_md5_hash       = NULL;
	internal_handle->acquiry_error_sectors     = NULL;
	internal_handle->acquiry_amount_of_errors  = 0;
	internal_handle->current_chunk             = 0;
	internal_handle->current_chunk_offset      = 0;
	internal_handle->swap_byte_pairs           = 0;
	internal_handle->compression_level         = EWF_COMPRESSION_UNKNOWN;
	internal_handle->amount_of_header_sections = 0;
	internal_handle->format                    = LIBEWF_FORMAT_UNKNOWN;
	internal_handle->ewf_format                = EWF_FORMAT_UNKNOWN;
	internal_handle->index_build               = 0;
	internal_handle->error_tollerance          = LIBEWF_ERROR_TOLLERANCE_COMPENSATE;

	internal_handle->segment_table = libewf_segment_table_alloc( segment_amount );

	if( internal_handle->segment_table == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_alloc: unable to create segment table.\n" );

		libewf_common_free( internal_handle );

		return( NULL );
	}
	internal_handle->chunk_cache = libewf_chunk_cache_alloc( EWF_MINIMUM_CHUNK_SIZE + EWF_CRC_SIZE );

	if( internal_handle->chunk_cache == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_alloc: unable to create chunk cache.\n" );

		libewf_segment_table_free( internal_handle->segment_table );
		libewf_common_free( internal_handle );

		return( NULL );
	}
	internal_handle->media = libewf_internal_handle_media_alloc();

	if( internal_handle->media == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_alloc: unable to create media subhandle.\n" );

		libewf_chunk_cache_free( internal_handle->chunk_cache );
		libewf_segment_table_free( internal_handle->segment_table );
		libewf_common_free( internal_handle );

		return( NULL );
	}
	if( ( flags == LIBEWF_OPEN_READ )
	 || ( flags == LIBEWF_OPEN_READ_WRITE ) )
	{
		internal_handle->read = libewf_internal_handle_read_alloc();

		if( internal_handle->read == NULL )
		{
			LIBEWF_WARNING_PRINT( "ewf_handle_alloc: unable to create read subhandle.\n" );

			libewf_internal_handle_media_free( internal_handle->media );
			libewf_chunk_cache_free( internal_handle->chunk_cache );
			libewf_segment_table_free( internal_handle->segment_table );
			libewf_common_free( internal_handle );

			return( NULL );
		}
	}
	if( ( flags == LIBEWF_OPEN_WRITE )
	 || ( flags == LIBEWF_OPEN_READ_WRITE ) )
	{
		internal_handle->write = libewf_internal_handle_write_alloc();

		if( internal_handle->write == NULL )
		{
			LIBEWF_WARNING_PRINT( "ewf_handle_alloc: unable to create write subhandle.\n" );

			if( internal_handle->read != NULL )
			{
				libewf_internal_handle_read_free( internal_handle->read );
			}
			libewf_internal_handle_media_free( internal_handle->media );
			libewf_chunk_cache_free( internal_handle->chunk_cache );
			libewf_segment_table_free( internal_handle->segment_table );
			libewf_common_free( internal_handle );

			return( NULL );
		}
	}
	return( internal_handle );
}

/* Frees memory of a handle struct including elements
 */
void libewf_internal_handle_free( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_free: invalid handle.\n" );

		return;
	}
	libewf_internal_handle_media_free( internal_handle->media );

	if( internal_handle->read != NULL )
	{
		libewf_internal_handle_read_free( internal_handle->read );
	}
	libewf_internal_handle_write_free( internal_handle->write );

	if( internal_handle->segment_table != NULL )
	{
		libewf_segment_table_free( internal_handle->segment_table );
	}
	if( internal_handle->offset_table != NULL )
	{
		libewf_offset_table_free( internal_handle->offset_table );
	}
	if( internal_handle->secondary_offset_table != NULL )
	{
		libewf_offset_table_free( internal_handle->secondary_offset_table );
	}
	libewf_common_free( internal_handle->acquiry_error_sectors );
	libewf_common_free( internal_handle->header );
	libewf_common_free( internal_handle->header2 );
	libewf_common_free( internal_handle->xheader );
	libewf_common_free( internal_handle->xhash );

	if( internal_handle->header_values != NULL )
	{
		libewf_header_values_free( internal_handle->header_values );
	}
	if( internal_handle->hash_values != NULL )
	{
		libewf_hash_values_free( internal_handle->hash_values );
	}
	libewf_common_free( internal_handle->stored_md5_hash );
	libewf_common_free( internal_handle->calculated_md5_hash );

	if( internal_handle->chunk_cache != NULL )
	{
		libewf_chunk_cache_free( internal_handle->chunk_cache );
	}
	libewf_common_free( internal_handle );
}

/* Allocates memory for a new handle media struct
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_INTERNAL_HANDLE_MEDIA *libewf_internal_handle_media_alloc( void )
{
	LIBEWF_INTERNAL_HANDLE_MEDIA *handle_media = NULL;

	handle_media = (LIBEWF_INTERNAL_HANDLE_MEDIA *) libewf_common_alloc( LIBEWF_INTERNAL_HANDLE_MEDIA_SIZE );

	if( handle_media == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_media_alloc: unable to allocate handle media.\n" );

		return( NULL );
	}
	handle_media->media_size        = 0;
	handle_media->chunk_size        = EWF_MINIMUM_CHUNK_SIZE;
	handle_media->sectors_per_chunk = 0;
	handle_media->bytes_per_sector  = 0;
	handle_media->amount_of_chunks  = 0;
	handle_media->amount_of_sectors = 0;
	handle_media->error_granularity = 0;
	handle_media->media_type        = 0;
	handle_media->media_flags       = 0x01;

	return( handle_media );
}

/* Allocates memory for a new handle read struct
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_INTERNAL_HANDLE_READ *libewf_internal_handle_read_alloc( void )
{
	LIBEWF_INTERNAL_HANDLE_READ *handle_read = NULL;

	handle_read = (LIBEWF_INTERNAL_HANDLE_READ *) libewf_common_alloc( LIBEWF_INTERNAL_HANDLE_READ_SIZE );

	if( handle_read == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_read_alloc: unable to allocate handle read.\n" );

		return( NULL );
	}
	handle_read->crc_error_sectors    = NULL;
	handle_read->crc_amount_of_errors = 0;
	handle_read->values_initialized   = 0;

	return( handle_read );
}

/* Frees memory of a handle read struct including elements
 */
void libewf_internal_handle_read_free( LIBEWF_INTERNAL_HANDLE_READ *handle_read )
{
	if( handle_read == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_read_free: invalid handle read.\n" );

		return;
	}
	libewf_common_free( handle_read->crc_error_sectors );
	libewf_common_free( handle_read );
}

/* Allocates memory for a new handle write struct
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_INTERNAL_HANDLE_WRITE *libewf_internal_handle_write_alloc( void )
{
	LIBEWF_INTERNAL_HANDLE_WRITE *handle_write = NULL;

	handle_write = (LIBEWF_INTERNAL_HANDLE_WRITE *) libewf_common_alloc( LIBEWF_INTERNAL_HANDLE_WRITE_SIZE );

	if( handle_write == NULL )
	{
		LIBEWF_WARNING_PRINT( "ewf_handle_write_alloc: unable to allocate handle write.\n" );

		return( NULL );
	}
	handle_write->input_write_count          = 0;
	handle_write->write_count                = 0;
	handle_write->input_write_size           = 0;
	handle_write->segment_file_size          = 0;
	handle_write->maximum_amount_of_segments = 0;
	handle_write->chunks_section_write_count = 0;
	handle_write->amount_of_chunks           = 0;
	handle_write->chunks_per_segment         = 0;
	handle_write->chunks_per_chunks_section  = 0;
	handle_write->segment_amount_of_chunks   = 0;
	handle_write->section_amount_of_chunks   = 0;
	handle_write->chunks_section_offset      = 0;
	handle_write->chunks_section_number      = 0;
	handle_write->compress_empty_block       = 0;
	handle_write->unrestrict_offset_amount   = 0;
	handle_write->values_initialized         = 0;
	handle_write->create_chunks_section      = 0;
	handle_write->write_finalized            = 0;

	return( handle_write );
}

/* Reallocates the handle chunk cache
 * Returns a pointer to the instance, NULL on error
 */
LIBEWF_INTERNAL_HANDLE *libewf_internal_handle_chunk_cache_realloc( LIBEWF_INTERNAL_HANDLE *internal_handle, size_t size )
{
	LIBEWF_CHUNK_CACHE *chunk_cache = NULL;

	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_chunk_cache_realloc: invalid handle.\n" );

		return( NULL );
	}
	if( internal_handle->chunk_cache == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_chunk_cache_realloc: invalid handle - missing chunk cache.\n" );

		return( NULL );
	}
	chunk_cache = libewf_chunk_cache_realloc( internal_handle->chunk_cache, size );

	if( chunk_cache == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_chunk_cache_realloc: unable to reallocate chunk cache.\n" );

		return( NULL );
	}
	internal_handle->chunk_cache = chunk_cache;

	return( internal_handle );
}

/* Check if the header value is set
 * Returns 0 if not set, 1 if set, or -1 on error
 */
int8_t libewf_internal_handle_is_set_header( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_is_set_header: invalid handle.\n" );

		return( -1 );
	}
	return( (uint8_t) ( internal_handle->header != NULL ) );
}

/* Check if the header2 value is set
 * Returns 0 if not set, 1 if set, or -1 on error
 */
int8_t libewf_internal_handle_is_set_header2( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_is_set_header2: invalid handle.\n" );

		return( -1 );
	}
	return( (uint8_t) ( internal_handle->header2 != NULL ) );
}

/* Check if the xheader value is set
 * Returns 0 if not set, 1 if set, or -1 on error
 */
int8_t libewf_internal_handle_is_set_xheader( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_is_set_xheader: invalid handle.\n" );

		return( -1 );
	}
	return( (uint8_t) ( internal_handle->xheader != NULL ) );
}

/* Check if the xhash value is set
 * Returns 0 if not set, 1 if set, or -1 on error