libewf_write.c

sleuthit-2.09 一个磁盘的工具集

/*
 * libewf file writing
 *
 * 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 <errno.h>

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include <libewf/libewf_definitions.h>

#include "libewf_char.h"
#include "libewf_chunk_cache.h"
#include "libewf_common.h"
#include "libewf_endian.h"
#include "libewf_file.h"
#include "libewf_notify.h"
#include "libewf_offset_table.h"
#include "libewf_read.h"
#include "libewf_section.h"
#include "libewf_section_list.h"
#include "libewf_segment_table.h"
#include "libewf_string.h"
#include "libewf_write.h"

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

/* Calculates an estimate of the amount of chunks that fit within a segment file
 * Returns the size or 0 on error
 */
uint32_t libewf_write_calculate_chunks_per_segment( LIBEWF_INTERNAL_HANDLE *internal_handle, uint16_t segment_number )
{
	int32_t available_segment_file_size = 0;
	int32_t maximum_chunks_per_segment  = 0;
	int32_t chunks_per_segment          = 0;
	int32_t remaining_amount_of_chunks  = 0;
	int32_t required_chunk_sections     = 1;

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

		return( 0 );
	}
	if( internal_handle->media == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_segment: invalid handle - missing subhandle media.\n" );

		return( 0 );
	}
	if( internal_handle->write == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_segment: invalid handle - missing subhandle write.\n" );

		return( 0 );
	}
	if( internal_handle->write->segment_file_size > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_segment: invalid segment file size only values below 2^32 are supported.\n" );

		return( 0 );
	}
	if( internal_handle->segment_table->file_offset[ segment_number ] > (off_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_segment: invalid segment file offset only values below 2^32 are supported.\n" );

		return( 0 );
	}
	/* If the amount of chunks already have been determined
	 */
	if( internal_handle->segment_table->amount_of_chunks[ segment_number ] > 0 )
	{
		return( internal_handle->segment_table->amount_of_chunks[ segment_number ] );
	}
	/* Calculate the available segment file size
	 */
	available_segment_file_size = (int32_t) internal_handle->write->segment_file_size - (int32_t) internal_handle->segment_table->file_offset[ segment_number ];

	/* Leave space for the done or next section
	 */
	available_segment_file_size -= EWF_SECTION_SIZE;

	/* Calculate the maximum amount of chunks within this segment file
	 */
	if( internal_handle->ewf_format == EWF_FORMAT_S01 )
	{
		/* The EWF-S01 format uses compression this will add 16 bytes on average
		 */
		maximum_chunks_per_segment = available_segment_file_size / ( internal_handle->media->chunk_size + 16 );
	}
	else
	{
		maximum_chunks_per_segment = available_segment_file_size / ( internal_handle->media->chunk_size + EWF_CRC_SIZE );
	}
	/* Determine the amount of required chunk sections
	 */
	if( internal_handle->write->unrestrict_offset_amount == 0 )
	{
		required_chunk_sections = maximum_chunks_per_segment % EWF_MAXIMUM_OFFSETS_IN_TABLE;
	}
	if( internal_handle->ewf_format == EWF_FORMAT_S01 )
	{
		/* Leave space for the chunk section starts
		 */
		available_segment_file_size -= ( required_chunk_sections * EWF_SECTION_SIZE );

		/* Leave space for the table offsets
		 */
		available_segment_file_size -= ( maximum_chunks_per_segment * EWF_TABLE_OFFSET_SIZE );
	}
	else if( internal_handle->format == LIBEWF_FORMAT_ENCASE1 )
	{
		/* Leave space for the chunk section starts and the offset table CRC
		 */
		available_segment_file_size -= ( required_chunk_sections * ( EWF_SECTION_SIZE + EWF_CRC_SIZE ) );

		/* Leave space for the table offsets
		 */
		available_segment_file_size -= ( maximum_chunks_per_segment * EWF_TABLE_OFFSET_SIZE );
	}
	else
	{
		/* Leave space for the chunk, table and table2 section starts and the offset table CRC
		 */
		available_segment_file_size -= ( required_chunk_sections * ( ( 3 * EWF_SECTION_SIZE ) + EWF_CRC_SIZE ) );

		/* Leave space for the table and table2 offsets
		 */
		available_segment_file_size -= 2 * ( maximum_chunks_per_segment * EWF_TABLE_OFFSET_SIZE );
	}
	/* Calculate the amount of chunks within this segment file
	 */
	if( internal_handle->ewf_format == EWF_FORMAT_S01 )
	{
		/* The EWF-S01 format uses compression this will add 16 bytes on average
		 */
		chunks_per_segment = available_segment_file_size / ( internal_handle->media->chunk_size + 16 );
	}
	else
	{
		chunks_per_segment = available_segment_file_size / ( internal_handle->media->chunk_size + EWF_CRC_SIZE );
	}
	/* If the input size is known
	 */
	if( internal_handle->write->input_write_size > 0 )
	{
		/* Calculate the amount of chunks that will remain
		 */
		remaining_amount_of_chunks = (int32_t) internal_handle->media->amount_of_chunks - (int32_t) internal_handle->write->amount_of_chunks;

		/* Check if the less chunks remain than the amount of chunks calculated
		 */
		if( remaining_amount_of_chunks < chunks_per_segment )
		{
			chunks_per_segment = remaining_amount_of_chunks;
		}
	}
	/* Make sure to return the total amount of chunks per segment
	 */
	if( internal_handle->write->segment_amount_of_chunks > 0 )
	{
		chunks_per_segment += internal_handle->write->segment_amount_of_chunks;
	}
	return( (uint32_t) chunks_per_segment );
}

/* Calculates the amount of chunks that fit within a chunks section
 * Returns the size or 0 on error
 */
uint32_t libewf_write_calculate_chunks_per_chunks_section( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	int32_t remaining_amount_of_chunks = 0;

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

		return( 0 );
	}
	if( internal_handle->media == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_chunks_section: invalid handle - missing subhandle media.\n" );

		return( 0 );
	}
	if( internal_handle->write == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_chunks_section: invalid handle - missing subhandle write.\n" );

		return( 0 );
	}
	if( internal_handle->write->chunks_per_segment > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_chunks_section: invalid chunks per segment only values below 2^32 are supported.\n" );

		return( 0 );
	}
	if( internal_handle->write->segment_file_size > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_chunks_section: invalid segment file size only values below 2^32 are supported.\n" );

		return( 0 );
	}
	if( internal_handle->write->chunks_section_number == 0 )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_calculate_chunks_per_chunks_section: unsupported section number: %" PRIu8 ".\n", internal_handle->write->chunks_section_number );

		return( 0 );
	}
	remaining_amount_of_chunks = (int32_t) internal_handle->write->chunks_per_segment;

	if( internal_handle->write->chunks_section_number > 1 )
	{
		remaining_amount_of_chunks -= ( ( internal_handle->write->chunks_section_number - 1 ) * EWF_MAXIMUM_OFFSETS_IN_TABLE );
	}
	if( remaining_amount_of_chunks <= 0 )
	{
		return( 0 );
	}
	else if( ( remaining_amount_of_chunks > EWF_MAXIMUM_OFFSETS_IN_TABLE ) && ( internal_handle->write->unrestrict_offset_amount == 0 ) )
	{
		return( EWF_MAXIMUM_OFFSETS_IN_TABLE );
	}
	return( (uint32_t) remaining_amount_of_chunks );
}

/* Tests if the current segment file is full
 * Returns 1 if full, 0 if not, -1 on error
 */
int8_t libewf_write_test_segment_file_full( LIBEWF_INTERNAL_HANDLE *internal_handle, off_t segment_file_offset )
{
	int32_t remaining_segment_file_size = 0;

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

		return( -1 );
	}
	if( internal_handle->media == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_test_segment_file_full: invalid handle - missing subhandle media.\n" );

		return( -1 );
	}
	if( internal_handle->write == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_test_segment_file_full: invalid handle - missing subhandle write.\n" );

		return( -1 );
	}
	if( segment_file_offset > (off_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_test_segment_file_full: invalid segment file offset only values below 2^32 are supported.\n" );

		return( -1 );
	}
	if( internal_handle->write->segment_file_size > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_test_segment_file_full: invalid segment file size only values below 2^32 are supported.\n" );

		return( -1 );
	}
	/* Check if a chunks segment file has been opened
	 */
	if( segment_file_offset == 0 )
	{
		LIBEWF_VERBOSE_PRINT( "libewf_write_test_segment_file_full: no segment file has been created.\n" );

		return( 0 );
	}
	/* Check if the maximum amount of chunks has been reached
	 */
	if( ( internal_handle->media->amount_of_chunks != 0 ) && ( internal_handle->media->amount_of_chunks == internal_handle->write->amount_of_chunks ) )
	{
		LIBEWF_VERBOSE_PRINT( "libewf_write_test_segment_file_full: all required chunks have been written.\n" );

		return( 1 );
	}
	/* Check if the end of the input has been reached
	*/
	if( ( internal_handle->write->input_write_size != 0 ) && ( internal_handle->write->input_write_count >= (int64_t) internal_handle->write->input_write_size ) )
	{
		LIBEWF_VERBOSE_PRINT( "libewf_write_test_segment_file_full: all required data has been written.\n" );

		return( 1 );
	}
	/* The EWF-S01 and EnCase1 format should use the pre calculated size
	 */
	if( ( internal_handle->ewf_format == EWF_FORMAT_S01 ) || ( internal_handle->format == LIBEWF_FORMAT_ENCASE1 ) )
	{
		if( internal_handle->write->segment_amount_of_chunks >= internal_handle->write->chunks_per_segment )
		{
			LIBEWF_VERBOSE_PRINT( "libewf_write_test_segment_file_full: no space left for additional chunk.\n" );

			return( 1 );
		}
	}
	else
	{
		/* Calculate the remaining segment file size
		 */
		remaining_segment_file_size = (int32_t) internal_handle->write->segment_file_size - (int32_t) segment_file_offset;

		/* Leave space for the done or next section
		 */
		remaining_segment_file_size -= EWF_SECTION_SIZE;

		/* Leave space for the table and table2 sections
		 */
		remaining_segment_file_size -= 2 * ( EWF_SECTION_SIZE + ( internal_handle->write->section_amount_of_chunks * EWF_TABLE_OFFSET_SIZE ) + EWF_CRC_SIZE );

		/* Determine if a chunk would fit in the segment file
		 */
		remaining_segment_file_size -= internal_handle->media->chunk_size + EWF_CRC_SIZE;

		if( remaining_segment_file_size <= 0 )
		{
			LIBEWF_VERBOSE_PRINT( "libewf_write_test_segment_file_full: no space left for additional chunk.\n" );

			return( 1 );
		}
	}
	LIBEWF_VERBOSE_PRINT( "libewf_write_test_segment_file_full: space left for additional chunk.\n" );

	return( 0 );
}

/* Tests if the current chunks section is full
 * Returns 1 if full, 0 if not, -1 on error
 */
int8_t libewf_write_test_chunks_section_full( LIBEWF_INTERNAL_HANDLE *internal_handle, off_t segment_file_offset )
{
	int32_t remaining_segment_file_size = 0;

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

		return( -1 );
	}
	if( internal_handle->media == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_write_test_chunks_section_full: invalid handle - missing subhandle media.\n" );

		return( -1 );
	}