libewf_internal_handle.c

sleuthit-2.09 一个磁盘的工具集

 */
int8_t libewf_internal_handle_is_set_xhash( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_is_set_xhash: invalid handle.\n" );

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

/* Returns the amount of sectors per chunk from the media information, 0 if not set, -1 on error
 */
int32_t libewf_internal_handle_get_media_sectors_per_chunk( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_sectors_per_chunk: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->sectors_per_chunk > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_sectors_per_chunk: invalid sector per chunk only values below 2^32 are supported.\n" );

		return( -1 );
	}
	return( internal_handle->media->sectors_per_chunk );
}

/* Returns the amount of bytes per sector from the media information, 0 if not set, -1 on error
 */
int32_t libewf_internal_handle_get_media_bytes_per_sector( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_bytes_per_sector: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->bytes_per_sector > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_bytes_per_sector: invalid bytes per sector only values below 2^32 are supported.\n" );

		return( -1 );
	}
	return( internal_handle->media->bytes_per_sector );
}

/* Returns the amount of sectors from the media information, 0 if not set, -1 on error
 */
int32_t libewf_internal_handle_get_media_amount_of_sectors( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_amount_of_sectors: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->amount_of_sectors > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_amount_of_sectors: invalid amount of sectors only values below 2^32 are supported.\n" );

		return( -1 );
	}
	return( internal_handle->media->amount_of_sectors );
}

/* Returns the chunk size from the media information, 0 if not set, -1 on error
 */
int32_t libewf_internal_handle_get_media_chunk_size( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_chunk_size: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->chunk_size > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_chunk_size: invalid chunk size only values below 2^32 are supported.\n" );

		return( -1 );
	}
	return( internal_handle->media->chunk_size );
}

/* Returns the error granularity from the media information, 0 if not set, -1 on error
 */
int32_t libewf_internal_handle_get_media_error_granularity( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_error_granularity: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->error_granularity > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_error_granularity: invalid error granularity only values below 2^32 are supported.\n" );

		return( -1 );
	}
	return( internal_handle->media->error_granularity );
}

/* Returns the compression level value, or -1 on error
 */
int8_t libewf_internal_handle_get_compression_level( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_compression_level: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->compression_level <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_compression_level: invalid compression level only positive values are supported.\n" );

		return( -1 );
	}
	return( (int8_t) internal_handle->compression_level );
}

/* Returns the size of the contained media data, 0 if not set, -1 on error
 */
int64_t libewf_internal_handle_get_media_size( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_size: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->media_size == 0 )
	{
		internal_handle->media->media_size = (uint64_t) internal_handle->media->amount_of_sectors * (uint64_t) internal_handle->media->bytes_per_sector;
	}
	if( internal_handle->media->media_size > (uint64_t) INT64_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_size: invalid media size only values below 2^64 are supported.\n" );

		return( -1 );
	}
	return( internal_handle->media->media_size );
}

/* Returns the media type value, or -1 on error
 */
int8_t libewf_internal_handle_get_media_type( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_type: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->media_type > (uint8_t) INT8_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_type: invalid media type only values below 2^8 are supported.\n" );

		return( -1 );
	}
	return( (int8_t) internal_handle->media->media_type );
}

/* Returns the media flags value, or -1 on error
 */
int8_t libewf_internal_handle_get_media_flags( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_flags: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->media->media_flags > (uint8_t) INT8_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_media_flags: invalid media flags only values below 2^8 are supported.\n" );

		return( -1 );
	}
	return( (int8_t) internal_handle->media->media_flags );
}

/* Returns the volume type value, or -1 on error
 */
int8_t libewf_internal_handle_get_volume_type( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_volume_type: invalid handle.\n" );

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

		return( -1 );
	}
	if( ( internal_handle->media->media_flags & 0x02 ) == 0 )
	{
		return( (int8_t) LIBEWF_VOLUME_TYPE_LOGICAL );
	}
	else
	{
		return( (int8_t) LIBEWF_VOLUME_TYPE_PHYSICAL );
	}
}

/* Returns the format value, or -1 on error
 */
int8_t libewf_internal_handle_get_format( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_format: invalid handle.\n" );

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

		return( -1 );
	}
	if( internal_handle->format > (uint8_t) INT8_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_format: invalid format only values below 2^8 are supported.\n" );

		return( -1 );
	}
	return( (int8_t) internal_handle->format );
}

/* Returns 1 if the GUID is set, or -1 on error
 */
int8_t libewf_internal_handle_get_guid( LIBEWF_INTERNAL_HANDLE *internal_handle, uint8_t *guid, size_t size )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_guid: invalid handle.\n" );

		return( -1 );
	}
	if( guid == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_guid: invalid guid.\n" );

		return( -1 );
	}
	if( size < 16 )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_guid: guid too small.\n" );

		return( -1 );
	}
	if( libewf_common_memcpy( guid, internal_handle->guid, 16 ) == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_guid: unable to set guid.\n" );

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

/* Returns the amount of chunks written, 0 if no chunks have been written, or -1 on error
 */
int64_t libewf_internal_handle_get_write_amount_of_chunks( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_write_amount_of_chunks: invalid handle.\n" );

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

		return( -1 );
	}
	return( (int64_t) internal_handle->write->amount_of_chunks );
}

/* Returns the maximum amount of supported segment files to write, or -1 on error
 */
int16_t libewf_internal_handle_get_write_maximum_amount_of_segments( LIBEWF_INTERNAL_HANDLE *internal_handle )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_write_maximum_amount_of_segments: invalid handle.\n" );

		return( -1 );
	}
	if( internal_handle->ewf_format == EWF_FORMAT_S01 )
	{
		/* = 4831
		 */
		return( (int16_t) ( ( (int) ( 'z' - 's' ) * 26 * 26 ) + 99 ) );
	}
	else if( internal_handle->ewf_format == EWF_FORMAT_E01 )
	{
		/* = 14295
		 */
		return( (int16_t) ( ( (int) ( 'Z' - 'E' ) * 26 * 26 ) + 99 ) );
	}
	else
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_write_maximum_amount_of_segments: unsupported EWF format.\n" );

		return( -1 );
	}
}

/* Retrieves the header value specified by identifier
 * Returns 1 if successful, 0 if value not present, -1 on error
 */
int8_t libewf_internal_handle_get_header_value( LIBEWF_INTERNAL_HANDLE *internal_handle, LIBEWF_CHAR *identifier, LIBEWF_CHAR *value, size_t length )
{
	if( internal_handle == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_header_value: invalid handle.\n" );

		return( -1 );
	}
	if( identifier == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_header_value: invalid indentifier.\n" );

		return( -1 );
	}
	if( value == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_internal_handle_get_header_value: invalid value.\n" );

		return( -1 );
	}
	if( internal_handle->header_values == NULL )
	{
		return( 0 );
	}
	return( libewf_header_values_get_value( internal_handle->header_values, identifier, value, length ) );
}

/* Retrieves the hash value specified by identifier
 * Returns 1 if successful, 0 if value not present, -1 on error
 */
int8_t libewf_internal_handle_get_hash_value( LIBEWF_INTERNAL_HANDLE *internal_handle, LIBEWF_CHAR *identifier, LIBEWF_CHAR *value, size_t length )
{
	if( internal_handle == NULL )
	{