libewf_header_values.c

sleuthit-2.09 一个磁盘的工具集

	if( header_values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_index: invalid header values.\n" );

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

		return( -1 );
	}
	identifier_length = libewf_string_length( identifier );

	if( identifier_length == 0 )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_index: invalid identifier.\n" );

		return( -1 );
	}
	if( header_values->amount > (uint32_t) INT32_MAX )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_index: invalid header values amount only values below 2^32 are supported.\n" );

		return( -1 );
	}
	for( iterator = 0; iterator < (int32_t) header_values->amount; iterator++ )
	{
		if( header_values->identifiers[ iterator ] == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_header_values_get_index: missing identifier for index: %" PRIi32 ".\n", iterator );

			continue;
		}
		string_length = libewf_string_length( header_values->identifiers[ iterator ] );

		if( string_length == 0 )
		{
			LIBEWF_WARNING_PRINT( "libewf_header_values_get_index: unable to determine length of identifier of index: %" PRIi32 ".\n", iterator );

			continue;
		}
		if( string_length != identifier_length )
		{
			continue;
		}
		if( libewf_string_compare( identifier, header_values->identifiers[ iterator ], identifier_length ) == 0 )
		{
			return( iterator );
		}
	}
	return( iterator );
}

/* Retrieves a header value in value
 * Length should contain the amount of characters in the string
 * Returns 1 if successful, 0 if value not present, -1 on error
 */
int8_t libewf_header_values_get_value( LIBEWF_HEADER_VALUES *header_values, LIBEWF_CHAR *identifier, LIBEWF_CHAR *value, size_t length )
{
	size_t header_value_length = 0;
	int32_t index              = 0;

	if( value == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_value: invalid value.\n" );

		return( -1 );
	}
	index = libewf_header_values_get_index( header_values, identifier );

	if( index <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_value: unable to find index for: %" PRIs_EWF ".\n", identifier );

		return( -1 );
	}
	if( (uint32_t) index > header_values->amount )
	{
		return( 0 );
	}
	if( header_values->values[ index ] == NULL )
	{
		return( 0 );
	}
	header_value_length = libewf_string_length( header_values->values[ index ] );

	/* Don't bother with empty values
	 */
	if( header_value_length == 0 )
	{
		return( 0 );
	}
	/* Add 1 additional byte required for the end of string character
	 */
	header_value_length += 1;

	if( header_value_length > length )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_value: value too small.\n" );

		return( -1 );
	}
	if( libewf_string_copy( value, header_values->values[ index ], header_value_length ) == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_get_value: unable to set header value.\n" );

		return( -1 );
	}
	value[ header_value_length - 1 ] = (LIBEWF_CHAR) '\0';

	return( 1 );
}

/* Set a header value
 * Length should contain the amount of characters in the string
 * Frees the previous header value if necessary
 * Returns 1 if successful, -1 on error
 */
int8_t libewf_header_values_set_value( LIBEWF_HEADER_VALUES *header_values, LIBEWF_CHAR *identifier, LIBEWF_CHAR *value, size_t length )
{
	size_t string_length = 0;
	int32_t index        = 0;

	index = libewf_header_values_get_index( header_values, identifier );

	if( index <= -1 )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_set_value: unable to find index for: %" PRIs_EWF ".\n", identifier );

		return( -1 );
	}
	if( (uint32_t) index >= header_values->amount )
	{
		string_length = libewf_string_length( identifier );

		if( string_length == 0 )
		{
			LIBEWF_WARNING_PRINT( "libewf_header_values_set_value: unable to determine length of identifier.\n" );

			return( -1 );
		}
		if( libewf_header_values_realloc( header_values, header_values->amount, ( index + 1 ) ) == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_header_values_set_value: unable to reallocate header values.\n" );

			return( -1 );
		}
		header_values->identifiers[ index ] = libewf_string_duplicate( identifier, string_length );

		if( header_values->identifiers[ index ] == NULL )
		{
			LIBEWF_WARNING_PRINT( "libewf_header_values_set_value: unable to set identifier.\n" );

			libewf_common_free( header_values->identifiers[ index ] );

			header_values->identifiers[ index ] = NULL;

			return( -1 );
		}
	}
	/* Clear the buffer of the previous header value
	 */
	if( header_values->values[ index ] != NULL )
	{
		libewf_common_free( header_values->values[ index ] );

		header_values->values[ index ] = NULL;
	}
	/* Don't bother with empty values
	 */
	if( value == NULL )
	{
		return( 1 );
	}
	if( length == 0 )
	{
		return( 1 );
	}
	header_values->values[ index ] = libewf_string_duplicate( value, length );

	if( header_values->values[ index ] == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_set_value: unable to set value.\n" );

		libewf_common_free( header_values->values[ index ] );

		header_values->values[ index ] = NULL;

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

/* Parse a header string for the values
 * Returns a pointer to the new instance, NULL on error
 */
LIBEWF_HEADER_VALUES *libewf_header_values_parse_header_string( LIBEWF_CHAR *header_string, size_t length, uint8_t date_format )
{
	LIBEWF_HEADER_VALUES *header_values = NULL;
	LIBEWF_CHAR **lines                 = NULL;
	LIBEWF_CHAR **types                 = NULL;
	LIBEWF_CHAR **values                = NULL;
	LIBEWF_CHAR *date_string            = NULL;
	size_t string_length                = 0;
	uint32_t line_count                 = 0;
	uint32_t type_count                 = 0;
	uint32_t value_count                = 0;
	uint32_t iterator                   = 0;

	if( header_string == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_parse_header_string: invalid header string\n" );

		return( NULL );
	}
	lines = libewf_string_split( (LIBEWF_CHAR *) header_string, length, (LIBEWF_CHAR) '\n', &line_count );

	if( lines == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_parse_header_string: unable to split lines in header string.\n" );

		return( NULL );
	}
	types = libewf_string_split( lines[ 2 ], libewf_string_length( lines[ 2 ] ), (LIBEWF_CHAR) '\t', &type_count );

	if( types == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_parse_header_string: unable to split types in header string.\n" );

		libewf_string_split_values_free( lines, line_count );

		return( NULL );
	}
	values = libewf_string_split( lines[ 3 ], libewf_string_length( lines[ 3 ] ), (LIBEWF_CHAR) '\t', &value_count );

	if( values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_parse_header_string: unable to split values in header string.\n" );

		libewf_string_split_values_free( lines, line_count );
		libewf_string_split_values_free( types, type_count );

		return( NULL );
	}
	libewf_string_split_values_free( lines, line_count );

	header_values = libewf_header_values_alloc();

	if( header_values == NULL )
	{
		LIBEWF_WARNING_PRINT( "libewf_header_values_parse_header_string: unable to create header values.\n" );

		libewf_string_split_values_free( types, type_count );
		libewf_string_split_values_free( values, value_count );

		return( NULL );
	}
	for( iterator = 0; iterator < type_count; iterator++ )
	{
		if( ( values[ iterator ] == NULL )
		 || ( values[ iterator ] == (LIBEWF_CHAR *) _S_LIBEWF_CHAR( "" ) ) )
		{
			continue;
		}
		string_length = libewf_string_length( values[ iterator ] );

		/* Remove trailing white space
		 */
		if( ( string_length > 0 ) && ( values[ iterator ][ string_length - 1 ] == (LIBEWF_CHAR) '\r' ) )
		{
			string_length -= 1;
		}
		if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "av" ), 2 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "acquiry_software_version" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set acquiry software version.\n" );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "dc" ), 2 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "unknown_dc" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set unknown: dc.\n" );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "md" ), 2 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "model" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set model.\n" );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "ov" ), 2 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "acquiry_operating_system" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set acquiry operating system.\n" );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "sn" ), 2 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "serial_number" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set serial_number.\n" );
			}
		}
		else if( ( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "m" ), 1 ) == 0 )
		      || ( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "u" ), 1 ) == 0 ) )
		{
			/* If the date string contains spaces it's in the old header
			 * format otherwise is in new header2 format
			 */
			if( libewf_string_search( values[ iterator ] , (LIBEWF_CHAR) ' ', string_length ) != NULL )
			{
				date_string = libewf_convert_date_header_value( values[ iterator ], date_format );
			}
			else
			{
				date_string = libewf_convert_date_header2_value( values[ iterator ], date_format );
			}
			if( date_string == NULL )
			{
				LIBEWF_WARNING_PRINT( "libewf_header_values_parse_header_string: unable to create date string.\n" );
			}
			else
			{
				/* The string length of the date string is needed
				 */
				string_length = libewf_string_length( date_string );

				if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "m" ), 1 ) == 0 )
				{
					if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "acquiry_date" ), date_string, string_length ) != 1 )
					{
						LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set acquiry date.\n" );
					}
				}
				else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "u" ), 1 ) == 0 )
				{
					if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "system_date" ), date_string, string_length ) != 1 )
					{
						LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set system date.\n" );
					}
				}
				libewf_common_free( date_string );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "p" ), 1 ) == 0 )
		{
			if( string_length == 0 )
			{
				/* Empty hash do nothing
				 */
			}
			else if( ( string_length == 1 ) && ( values[ iterator ][ 0 ] == (LIBEWF_CHAR) '0' ) )
			{
				/* Empty hash do nothing
				 */
			}
			else
			{
				if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "password" ), values[ iterator ], string_length ) != 1 )
				{
					LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set password.\n" );
				}
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "a" ), 1 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "description" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set description.\n" );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "c" ), 1 ) == 0 )
		{
			if( libewf_header_values_set_value( header_values, _S_LIBEWF_CHAR( "case_number" ), values[ iterator ], string_length ) != 1 )
			{
				LIBEWF_VERBOSE_PRINT( "libewf_header_values_parse_header_string: unable to set case number.\n" );
			}
		}
		else if( libewf_string_compare( types[ iterator ], _S_LIBEWF_CHAR( "n" ), 1 ) == 0 )