libewf.h — Library to access the Expert Witness Compression Format (EWF) format

Author

       These man pages were written by Joachim Metz.

Bugs

       Please  report  bugs  of  any  kind  on  the  project  issue  tracker:  https://github.com/libyal/libewf-
       legacy/issues

Copyright

       Copyright 2006-2022, Joachim Metz <joachim.metz@gmail.com>.  This is free software; see  the  source  for
       copying  conditions.  There  is  NO  warranty;  not  even for MERCHANTABILITY or FITNESS FOR A PARTICULAR
       PURPOSE.

Description

       The libewf_get_version() function is used to retrieve the library version.

       The libewf_get_flags_*() functions are used to get the values of the flags for read and/or write.

       The libewf_check_file_signature() and libewf_check_file_signature_wide() functions are used  to  test  if
       the EWF file signature is present within a certain filename.

       The  libewf_glob()  and  libewf_glob_wide()  functions  glob  filenames using the filename and the format
       according to the EWF segment file naming schema.  If the format is known the filename should contain  the
       base of the filename otherwise the function will try to determine the format based on the extension.

       The libewf_handle_signal_abort() function signals the handle to aborts it current activity.

       The  libewf_handle_open(), libewf_handle_open_wide(), libewf_handle_close(), libewf_handle_read_buffer(),
       libewf_handle_read_random(),         libewf_handle_write_buffer(),          libewf_handle_write_random(),
       libewf_handle_seek_offset()  functions  can be used to open, seek in, read from, write to and close a set
       of EWF files.

       The libewf_handle_write_finalize() function needs to be called after writing a set of EWF  files  without
       knowing  the  input  size  upfront,  e.g.  reading  from a pipe.  libewf_handle_write_finalize() will the
       necessary correction to the set of EWF files.

       The libewf_handle_prepare_read_chunk(), libewf_handle_read_chunk() functions can be used to  read  chunks
       to a set of EWF files.

       The  libewf_handle_prepare_write_chunk(),  libewf_handle_write_chunk()  functions  can  be  used to write
       chunks to a set of EWF files.

       The libewf_handle_get_*() functions can be used to retrieve information from the handle. This information
       is read from a set of EWF files when libewf_handle_open() or libewf_handle_open_wide() is used.

       The libewf_handle_set_*() functions can be used to set information in the  handle.  This  information  is
       written to a set of EWF files when libewf_handle_write_buffer() is used.

       The  libewf_handle_append_acquiry_error()  function  can be used to append an acquiry error (a read error
       during acquiry) to be written into a set of EWF files.

       The libewf_handle_append_checksum_error() function can be used to append an Adler-32  checksum  error  (a
       validation error in a chunk in a set of EWF files) to be set in the handle.

       The  libewf_handle_append_session()  function can be used to append a session to be written into a set of
       EWF files. Note that the only the start offset is stored in a set of EWF files. Libewf ignores the number
       of sectors on write and determines the session sizes using the available session and media information on
       read.

       The libewf_handle_copy_*() functions copy information from the source_handle to the destination_handle.

       The libewf_notify_set_verbose(), libewf_notify_set_stream() functions can be used to direct the  warning,
       verbose and debug output from the library.

Environment

       None

Files

       None

Name

       libewf.h — Library to access the Expert Witness Compression Format (EWF) format

Notes

libewf supports both UTF-8 and UTF-16 encoded strings except for filenames. Some platforms like WINAPI
require wide character support for Unicode filenames. To compile libewf with wide character support use
./configure--enable-wide-character-type=yes or pass the definition _UNICODE
or UNICODE
to the compiler (i.e. in case of Microsoft Visual Studio (MSVS) C++).

To have other code to determine if libewf was compiled with wide character support it defines
LIBEWF_HAVE_WIDE_CHARACTER_TYPE
in libewf/features.h.

The header in a set of EWF files contains an extended ASCII string using the codepage of the system it
was created on. The function libewf_handle_set_header_codepage
allows one to set the required codepage for reading and writing. The default codepage is ASCII and
replaces all extended characters to the Unicode replacement character (U+fffd) when reading and the ASCII
substitute character (0x1a) when writing.

The header2 contains UTF-16 little endian stream and the xheader and xhash contain a UTF-8 stream without
or with byte order mark (as of version 20080903).

libewf allows one to be compiled with chained IO support using libbfio. libewf will automatically detect
if a compatible version of libbfio is available.

To have other code to determine if libewf was compiled with libbfio support it defines LIBEWF_HAVE_BFIO
in libewf/features.h.

Return Values

       Most  of  the  functions  return NULL or -1 on error, dependent on the return type. For the actual return
       values refer to libewf.h

       To determine the cause of an error pass a reference to libewf_error_t *error = NULL. libewf  will  create
       an  error  object  that must be freed with the libewf_error_free function. If the error reference is NULL
       libewf will not create an error object.

Synopsis

#include<libewf.h>

       Support functions

       constchar*libewf_get_version(void);

       intlibewf_get_access_flags_read(void);

       intlibewf_get_access_flags_read_write(void);

       intlibewf_get_access_flags_write(void);

       intlibewf_get_access_flags_write_resume(void);

       intlibewf_get_codepage(int*codepage, libewf_error_t**error);

       intlibewf_set_codepage(intcodepage, libewf_error_t**error);

       intlibewf_check_file_signature(constchar*filename, libewf_error_t**error);

       intlibewf_glob(constchar*filename,   size_tfilename_length,  uint8_tformat,  char**filenames[],
           int*number_of_filenames, libewf_error_t**error);

       intlibewf_glob_free(char*filenames[], intnumber_of_filenames, libewf_error_t**error);

       Available when compiled with wide character string support:

       intlibewf_check_file_signature_wide(constwchar_t*filename, libewf_error_t**error);

       intlibewf_glob_wide(constwchar_t*filename, size_tfilename_length, uint8_tformat, wchar_t**filenames[],
           int*number_of_filenames, libewf_error_t**error);

       intlibewf_glob_wide_free(wchar_t*filenames[], intnumber_of_filenames, libewf_error_t**error);

       Available when compiled with libbfio support:

       intlibewf_check_file_signature_file_io_handle(libbfio_handle_t*file_io_handle, libewf_error_t**error);

       Notify functions

       voidlibewf_notify_set_verbose(intverbose);

       intlibewf_notify_set_stream(FILE*stream, libewf_error_t**error);

       intlibewf_notify_stream_open(constchar*filename, libewf_error_t**error);

       intlibewf_notify_stream_close(libewf_error_t**error);

       Error functions

       voidlibewf_error_free(libewf_error_t**error);

       intlibewf_error_fprint(libewf_error_t*error, FILE*stream);

       intlibewf_error_sprint(libewf_error_t*error, char*string, size_tsize);

       intlibewf_error_backtrace_fprint(libewf_error_t*error, FILE*stream);

       intlibewf_error_backtrace_sprint(libewf_error_t*error, char*string, size_tsize);

       Handle functions

       intlibewf_handle_initialize(libewf_handle_t**handle, libewf_error_t**error);

       intlibewf_handle_free(libewf_handle_t**handle, libewf_error_t**error);

       intlibewf_handle_signal_abort(libewf_handle_t*handle, libewf_error_t**error);

       intlibewf_handle_clone(libewf_handle_t**destination_handle,      libewf_handle_t*source_handle,
           libewf_error_t**error);

       intlibewf_handle_open(libewf_handle_t*handle,  char*constfilenames[],   intnumber_of_filenames,
           intaccess_flags, libewf_error_t**error);

       intlibewf_handle_close(libewf_handle_t*handle, libewf_error_t**error);

       ssize_tlibewf_handle_prepare_read_chunk(libewf_handle_t*handle,  void*chunk_buffer, size_tchunk_buffer_size,
           void*uncompressed_chunk_buffer,  size_t*uncompressed_chunk_buffer_size,   int8_tis_compressed,
           uint32_tchunk_checksum, int8_tchunk_io_flags, libewf_error_t**error);

       ssize_tlibewf_handle_read_chunk(libewf_handle_t*handle,   void*chunk_buffer,   size_tchunk_buffer_size,
           int8_t*is_compressed,  void*checksum_buffer,  uint32_t*chunk_checksum,  int8_t*chunk_io_flags,
           libewf_error_t**error);

       ssize_tlibewf_handle_read_buffer(libewf_handle_t*handle,     void*buffer,     size_tbuffer_size,
           libewf_error_t**error);

       ssize_tlibewf_handle_read_random(libewf_handle_t*handle, void*buffer,  size_tbuffer_size,  off64_toffset,
           libewf_error_t**error);

       ssize_tlibewf_handle_prepare_write_chunk(libewf_handle_t*handle, void*chunk_buffer, size_tchunk_buffer_size,
           void*compressed_chunk_buffer,   size_t*compressed_chunk_buffer_size,   int8_t*is_compressed,
           uint32_t*chunk_checksum, int8_t*chunk_io_flags, libewf_error_t**error);

       ssize_tlibewf_handle_write_chunk(libewf_handle_t*handle,   void*chunk_buffer,   size_tchunk_buffer_size,
           size_tdata_size,  int8_tis_compressed,  constvoid*checksum_buffer,  uint32_tchunk_checksum,
           int8_tchunk_io_flags, libewf_error_t**error);

       ssize_tlibewf_handle_write_buffer(libewf_handle_t*handle,    constvoid*buffer,   size_tbuffer_size,
           libewf_error_t**error);

       ssize_tlibewf_handle_write_random(libewf_handle_t*handle,   constvoid*buffer,    size_tbuffer_size,
           off64_toffset, libewf_error_t**error);

       ssize_tlibewf_handle_write_finalize(libewf_handle_t*handle, libewf_error_t**error);

       off64_tlibewf_handle_seek_offset(libewf_handle_t*handle, off64_toffset, intwhence, libewf_error_t**error);

       off64_tlibewf_handle_get_offset(libewf_handle_t*handle, libewf_error_t**error);

       intlibewf_handle_set_maximum_number_of_open_handles(libewf_handle_t*handle,
           intmaximum_number_of_open_handles, libewf_error_t**error);

       intlibewf_handle_get_segment_filename_size(libewf_handle_t*handle,       size_t*filename_size,
           libewf_error_t**error);

       intlibewf_handle_get_segment_filename(libewf_handle_t*handle,   char*filename,  size_tfilename_size,
           libewf_error_t**error);

       intlibewf_handle_set_segment_filename(libewf_handle_t*handle, constchar*filename, size_tfilename_length,
           libewf_error_t**error);

       intlibewf_handle_set_maximum_segment_size(libewf_handle_t*handle,    size64_t*maximum_segment_size,
           libewf_error_t**error);

       intlibewf_handle_set_maximum_segment_size(libewf_handle_t*handle,     size64_tmaximum_segment_size,
           libewf_error_t**error);

       intlibewf_handle_get_delta_segment_filename_size(libewf_handle_t*handle,     size_t*filename_size,
           libewf_error_t**error);

       intlibewf_handle_get_delta_segment_filename(libewf_handle_t*handle,  char*filename, size_tfilename_size,
           libewf_error_t**error);

       intlibewf_handle_set_delta_segment_filename(libewf_handle_t*handle,     constchar*filename,
           size_tfilename_length, libewf_error_t**error);

       intlibewf_handle_get_maximum_delta_segment_size(libewf_handle_t*handle,
           size64_t*maximum_delta_segment_size, libewf_error_t**error);

       intlibewf_handle_set_maximum_delta_segment_size(libewf_handle_t*handle,
           size64_tmaximum_delta_segment_size, libewf_error_t**error);

       intlibewf_handle_segment_files_corrupted(libewf_handle_t*handle, libewf_error_t**error);

       intlibewf_handle_segment_files_encrypted(libewf_handle_t*handle, libewf_error_t**error);

       intlibewf_handle_get_filename_size(libewf_handle_t*handle, size_t*filename_size, libewf_error_t**error);

       intlibewf_handle_get_filename(libewf_handle_t*handle,    char*filename,    size_tfilename_size,
           libewf_error_t**error);

       Available when compiled with wide character string support:

       intlibewf_handle_open_wide(libewf_handle_t*handle, wchar_t*constfilenames[],  intnumber_of_filenames,
           intaccess_flags, libewf_error_t**error);

       intlibewf_handle_get_segment_filename_size_wide(libewf_handle_t*handle,     size_t*filename_size,
           libewf_error_t**error);

       intlibewf_handle_get_segment_filename_wide(libewf_handle_t*handle, wchar_t*filename, size_tfilename_size,
           libewf_error_t**error);

       intlibewf_handle_set_segment_filename_wide(libewf_handle_t*handle,     constwchar_t*filename,
           size_tfilename_length, libewf_error_t**error);

       intlibewf_handle_get_delta_segment_filename_size_wide(libewf_handle_t*handle,   size_t*filename_size,
           libewf_error_t**error);

       intlibewf_handle_get_delta_segment_filename_wide(libewf_handle_t*handle,      wchar_t*filename,
           size_tfilename_size, libewf_error_t**error);

       intlibewf_handle_set_delta_segment_filename_wide(libewf_handle_t*handle,    constwchar_t*filename,
           size_tfilename_length, libewf_error_t**error);

       intlibewf_handle_get_filename_size_wide(libewf_handle_t*handle,        size_t*filename_size,
           libewf_error_t**error);

       intlibewf_handle_get_filename_wide(libewf_handle_t*handle,   wchar_t*filename,  size_tfilename_size,
           libewf_error_t**error);

       Available when compiled with libbfio support:

       intlibewf_handle_open_file_io_pool(libewf_handle_t*handle, libbfio_pool_t*file_io_pool, intaccess_flags,
           libewf_error_t**error);

       intlibewf_handle_get_file_io_handle(libewf_handle_t*handle,     libbfio_handle_t**file_io_handle,
           libewf_error_t**error);

       Meta data functions

       intlibewf_handle_get_sectors_per_chunk(libewf_handle_t*handle,      uint32_t*sectors_per_chunk,
           libewf_error_t**error);

       intlibewf_handle_set_sectors_per_chunk(libewf_handle_t*handle,       uint32_tsectors_per_chunk,
           libewf_error_t**error);

       intlibewf_handle_get_bytes_per_sector(libewf_handle_t*handle,       uint32_t*bytes_per_sector,
           libewf_error_t**error);

       intlibewf_handle_set_bytes_per_sector(libewf_handle_t*handle,       uint32_tbytes_per_sector,
           libewf_error_t**error);

       intlibewf_handle_get_number_of_sectors(libewf_handle_t*handle,      uint64_t*number_of_sectors,
           libewf_error_t**error);

       intlibewf_handle_get_chunk_size(libewf_handle_t*handle,  size32_t*chunk_size,  libewf_error_t**error,
           libewf_error_t**error);

       intlibewf_handle_get_error_granularity(libewf_handle_t*handle,      uint32_t*error_granularity,
           libewf_error_t**error);

       intlibewf_handle_set_error_granularity(libewf_handle_t*handle,       uint32_terror_granularity,
           libewf_error_t**error);

       intlibewf_handle_get_compression_method(libewf_handle_t*handle,      uint16_t*compression_method,
           libewf_error_t**error);

       intlibewf_handle_set_compression_method(libewf_handle_t*handle,      uint16_tcompression_method,
           libewf_error_t**error);

       intlibewf_handle_get_compression_values(libewf_handle_t*handle,       int8_t*compression_level,
           uint8_t*compression_flags, libewf_error_t**error);

       intlibewf_handle_set_compression_values(libewf_handle_t*handle,       int8_tcompression_level,
           uint8_tcompression_flags, libewf_error_t**error);

       intlibewf_handle_get_media_size(libewf_handle_t*handle, size64_t*media_size, libewf_error_t**error);

       intlibewf_handle_set_media_size(libewf_handle_t*handle, size64_tmedia_size, libewf_error_t**error);

       intlibewf_handle_get_media_type(libewf_handle_t*handle, uint8_t*media_type, libewf_error_t**error);

       intlibewf_handle_set_media_type(libewf_handle_t*handle, uint8_tmedia_type, libewf_error_t**error);

       intlibewf_handle_get_media_flags(libewf_handle_t*handle, uint8_t*media_flags, libewf_error_t**error);

       intlibewf_handle_set_media_flags(libewf_handle_t*handle, uint8_tmedia_flags, libewf_error_t**error);

       intlibewf_handle_get_format(libewf_handle_t*handle, uint8_t*format, libewf_error_t**error);

       intlibewf_handle_set_format(libewf_handle_t*handle, uint8_tformat, libewf_error_t**error);

       intlibewf_handle_get_segment_file_version(libewf_handle_t*handle,       uint8_t*major_version,
           uint8_t*minor_version, libewf_error_t**error);

       intlibewf_handle_get_segment_file_set_identifier(libewf_handle_t*handle,    uint8_t*set_identifier,
           size_tsize, libewf_error_t**error);

       intlibewf_handle_set_segment_file_set_identifier(libewf_handle_t*handle,    uint8_t*set_identifier,
           size_tsize, libewf_error_t**error);

       intlibewf_handle_get_md5_hash(libewf_handle_t*handle,      uint8_t*md5_hash,     size_tsize,
           libewf_error_t**error);

       intlibewf_handle_set_md5_hash(libewf_handle_t*handle,   constuint8_t*md5_hash,    size_tsize,
           libewf_error_t**error);

       intlibewf_handle_get_sha1_hash(libewf_handle_t*handle,     uint8_t*sha1_hash,     size_tsize,
           libewf_error_t**error);

       intlibewf_handle_set_sha1_hash(libewf_handle_t*handle,   constuint8_t*sha1_hash,    size_tsize,
           libewf_error_t**error);

       intlibewf_handle_set_read_zero_chunk_on_error(libewf_handle_t*handle,      uint8_tzero_on_error,
           libewf_error_t**error);

       intlibewf_handle_copy_media_values(libewf_handle_t*destination_handle,   libewf_handle_t*source_handle,
           libewf_error_t**error);

       intlibewf_handle_get_number_of_acquiry_errors(libewf_handle_t*handle,    uint32_t*number_of_errors,
           libewf_error_t**error);

       intlibewf_handle_get_acquiry_error(libewf_handle_t*handle,   uint32_tindex,   uint64_t*start_sector,
           uint64_t*number_of_sectors, libewf_error_t**error);

       intlibewf_handle_append_acquiry_error(libewf_handle_t*handle,         uint64_tstart_sector,
           uint64_tnumber_of_sectors, libewf_error_t**error);

       intlibewf_handle_get_number_of_checksum_errors(libewf_handle_t*handle,    uint32_t*number_of_errors,
           libewf_error_t**error);

       intlibewf_handle_get_checksum_error(libewf_handle_t*handle,   uint32_tindex,  uint64_t*start_sector,
           uint64_t*number_of_sectors, libewf_error_t**error);

       intlibewf_handle_append_checksum_error(libewf_handle_t*handle,        uint64_tstart_sector,
           uint64_tnumber_of_sectors, libewf_error_t**error);

       intlibewf_handle_get_number_of_sessions(libewf_handle_t*handle,      uint32_t*number_of_sessions,
           libewf_error_t**error);

       intlibewf_handle_get_session(libewf_handle_t*handle,    uint32_tindex,    uint64_t*start_sector,
           uint64_t*number_of_sectors, libewf_error_t**error);

       intlibewf_handle_append_session(libewf_handle_t*handle, uint64_tstart_sector, uint64_tnumber_of_sectors,
           libewf_error_t**error);

       intlibewf_handle_get_number_of_tracks(libewf_handle_t*handle,       uint32_t*number_of_tracks,
           libewf_error_t**error);

       intlibewf_handle_get_track(libewf_handle_t*handle,     uint32_tindex,    uint64_t*start_sector,
           uint64_t*number_of_sectors, libewf_error_t**error);

       intlibewf_handle_append_track(libewf_handle_t*handle, uint64_tstart_sector,  uint64_tnumber_of_sectors,
           libewf_error_t**error);

       intlibewf_handle_get_header_codepage(libewf_handle_t*handle, int*codepage, libewf_error_t**error);

       intlibewf_handle_set_header_codepage(libewf_handle_t*handle, intcodepage, libewf_error_t**error);

       intlibewf_handle_get_header_values_data_format(libewf_handle_t*handle,        intdate_format,
           libewf_error_t**error);

       intlibewf_handle_set_header_values_data_format(libewf_handle_t*handle,        intdate_format,
           libewf_error_t**error);

       intlibewf_handle_get_number_of_header_values(libewf_handle_t*handle,     uint32_t*number_of_values,
           libewf_error_t**error);

       intlibewf_handle_get_header_value_identifier_size(libewf_handle_t*handle,       uint32_tindex,
           size_t*identifier_size, libewf_error_t**error);

       intlibewf_handle_get_header_value_identifier(libewf_handle_t*handle,  uint32_tindex, uint8_t*identifier,
           size_tidentifier_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_size(libewf_handle_t*handle,    constuint8_t*identifier,
           size_tidentifier_length, size_t*utf8_string_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value(libewf_handle_t*handle,      constuint8_t*identifier,
           size_tidentifier_length, uint8_t*utf8_string, size_tutf8_string_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_case_number(libewf_handle_t*handle,       uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_description(libewf_handle_t*handle,       uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_examiner_name(libewf_handle_t*handle,      uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_evidence_number(libewf_handle_t*handle,     uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_notes(libewf_handle_t*handle,  uint8_t*value,  size_tvalue_size,
           libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_acquiry_date(libewf_handle_t*handle,      uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_system_date(libewf_handle_t*handle,       uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_acquiry_operating_system(libewf_handle_t*handle,  uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_acquiry_software_version(libewf_handle_t*handle,  uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_password(libewf_handle_t*handle, uint8_t*value, size_tvalue_size,
           libewf_error_t**error);

       intlibewf_handle_get_utf8_header_value_compression_level(libewf_handle_t*handle,     uint8_t*value,
           size_tvalue_size, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value(libewf_handle_t*handle,      constuint8_t*identifier,
           constuint8_t*utf8_string, size_tutf8_string_length);

       intlibewf_handle_set_utf8_header_value_case_number(libewf_handle_t*handle,    constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_description(libewf_handle_t*handle,    constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_examiner_name(libewf_handle_t*handle,   constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_evidence_number(libewf_handle_t*handle,   constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_notes(libewf_handle_t*handle,     constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_acquiry_date(libewf_handle_t*handle,    constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_system_date(libewf_handle_t*handle,    constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_acquiry_operating_system(libewf_handle_t*handle,
           constuint8_t*value, size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_acquiry_software_version(libewf_handle_t*handle,
           constuint8_t*value, size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_password(libewf_handle_t*handle,     constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_compression_level(libewf_handle_t*handle,  constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_model(libewf_handle_t*handle,     constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_set_utf8_header_value_serial_number(libewf_handle_t*handle,   constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_get_utf16_header_value_size(libewf_handle_t*handle,    constuint8_t*identifier,
           size_tidentifier_length, size_t*utf16_string_size, libewf_error_t**error);

       intlibewf_handle_get_utf16_header_value(libewf_handle_t*handle,     constuint8_t*identifier,
           size_tidentifier_length, uint16_t*utf16_string, size_tutf16_string_size, libewf_error_t**error);

       intlibewf_handle_set_utf16_header_value(libewf_handle_t*handle,     constuint8_t*identifier,
           constuint16_t*utf16_string, size_tutf16_string_length);

       intlibewf_handle_copy_header_values(libewf_handle_t*destination_handle,  libewf_handle_t*source_handle,
           libewf_error_t**error);

       intlibewf_handle_get_number_of_hash_values(libewf_handle_t*handle,     uint32_t*number_of_values,
           libewf_error_t**error);

       intlibewf_handle_get_hash_value_identifier_size(libewf_handle_t*handle,        uint32_tindex,
           size_t*identifier_size, libewf_error_t**error);

       intlibewf_handle_get_hash_value_identifier(libewf_handle_t*handle,  uint32_tindex,  uint8_t*identifier,
           size_tidentifier_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_hash_value_size(libewf_handle_t*handle,     constuint8_t*identifier,
           size_tidentifier_length, size_t*utf8_string_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_hash_value(libewf_handle_t*handle,      constuint8_t*identifier,
           size_tidentifier_length, uint8_t*utf8_string, size_tutf8_string_size, libewf_error_t**error);

       intlibewf_handle_get_utf8_hash_value_md5(libewf_handle_t*handle,  uint8_t*value,   size_tvalue_size,
           libewf_error_t**error);

       intlibewf_handle_get_utf8_hash_value_sha1(libewf_handle_t*handle,   uint8_t*value,  size_tvalue_size,
           libewf_error_t**error);

       intlibewf_handle_set_utf8_hash_value(libewf_handle_t*handle,      constuint8_t*identifier,
           size_tidentifier_length,     constuint8_t*utf8_string,    size_tutf8_string_length,
           libewf_error_t**error);

       intlibewf_handle_set_utf8_hash_value_md5(libewf_handle_t*handle, constuint8_t*value, size_tvalue_length,
           libewf_error_t**error);

       intlibewf_handle_set_utf8_hash_value_sha1(libewf_handle_t*handle,      constuint8_t*value,
           size_tvalue_length, libewf_error_t**error);

       intlibewf_handle_get_utf16_hash_value_size(libewf_handle_t*handle,     constuint8_t*identifier,
           size_tidentifier_length, size_t*utf16_string_size, libewf_error_t**error);

       intlibewf_handle_get_utf16_hash_value(libewf_handle_t*handle,      constuint8_t*identifier,
           size_tidentifier_length, uint16_t*utf16_string, size_tutf16_string_size, libewf_error_t**error);

       intlibewf_handle_set_utf16_hash_value(libewf_handle_t*handle,      constuint8_t*identifier,
           size_tidentifier_length,    constuint16_t*utf16_string,    size_tutf16_string_length,
           libewf_error_t**error);

       intlibewf_handle_get_root_file_entry(libewf_handle_t*handle,    libewf_file_entry_t**root_file_entry,
           libewf_error_t**error);

       intlibewf_file_get_file_entry_by_utf8_path(libewf_handle_t*handle,    constuint8_t*utf8_string,
           size_tutf8_string_length, libewf_file_entry_t**file_entry, libewf_error_t**error);

       intlibewf_file_get_file_entry_by_utf16_path(libewf_handle_t*handle,    constuint16_t*utf16_string,
           size_tutf16_string_length, libewf_file_entry_t**file_entry, libewf_error_t**error);

       Single file entry functions

       intlibewf_file_entry_free(libewf_file_entry_t**file_entry, libewf_error_t**error);

       intlibewf_file_entry_get_type(libewf_file_entry_t*file_entry, uint8_t*type, libewf_error_t**error);

       intlibewf_file_entry_get_flags(libewf_file_entry_t*file_entry, uint32_t*flags, libewf_error_t**error);

       int();

       libewf_file_entry_get_media_data_offsetlibewf_file_entry_t*file_entryoff64_t*media_data_offsetlibewf_error_t**errorint();

       libewf_file_entry_get_media_data_sizelibewf_file_entry_t*file_entrysize64_t*media_data_sizelibewf_error_t**errorint();

       libewf_file_entry_get_duplicate_media_data_offsetlibewf_file_entry_t*file_entryoff64_t*duplicate_media_data_offsetlibewf_error_t**errorintlibewf_file_entry_get_utf8_name_size(libewf_file_entry_t*file_entry,    size_t*utf8_string_size,
           libewf_error_t**error);

       intlibewf_file_entry_get_utf8_name(libewf_file_entry_t*file_entry,       uint8_t*utf8_string,
           size_tutf8_string_size, libewf_error_t**error);

       intlibewf_file_entry_get_utf16_name_size(libewf_file_entry_t*file_entry,    size_t*utf16_string_size,
           libewf_error_t**error);

       intlibewf_file_entry_get_utf16_name(libewf_file_entry_t*file_entry,      uint16_t*utf16_string,
           size_tutf16_string_size, libewf_error_t**error);

       intlibewf_file_entry_get_size(libewf_file_entry_t*file_entry, size64_t*size, libewf_error_t**error);

       intlibewf_file_entry_get_creation_time(libewf_file_entry_t*file_entry,     uint32_t*creation_time,
           libewf_error_t**error);

       intlibewf_file_entry_get_modification_time(libewf_file_entry_t*file_entry,  uint32_t*modification_time,
           libewf_error_t**error);

       intlibewf_file_entry_get_access_time(libewf_file_entry_t*file_entry,      uint32_t*access_time,
           libewf_error_t**error);

       intlibewf_file_entry_get_entry_modification_time(libewf_file_entry_t*file_entry,
           uint32_t*entry_modification_time, libewf_error_t**error);

       intlibewf_file_entry_get_utf8_hash_value_md5(libewf_file_entry_t*file_entry,    uint8_t*utf8_string,
           size_tutf8_string_size, libewf_error_t**error);

       intlibewf_file_entry_get_utf16_hash_value_md5(libewf_file_entry_t*file_entry,   uint8_t*utf16_string,
           size_tutf16_string_size, libewf_error_t**error);

       intlibewf_file_entry_get_utf8_hash_value_sha1(libewf_file_entry_t*file_entry,    uint8_t*utf8_string,
           size_tutf8_string_size, libewf_error_t**error);

       intlibewf_file_entry_get_utf16_hash_value_sha1(libewf_file_entry_t*file_entry,   uint8_t*utf16_string,
           size_tutf16_string_size, libewf_error_t**error);

       ssize_tlibewf_file_entry_read_buffer(libewf_file_entry_t*file_entry,   void*buffer,   size_tbuffer_size,
           libewf_error_t**error);

       ssize_tlibewf_file_entry_read_random(libewf_file_entry_t*file_entry,   void*buffer,   size_tbuffer_size,
           off64_toffset, libewf_error_t**error);

       off64_tlibewf_file_entry_seek_offset(libewf_file_entry_t*file_entry,    off64_toffset,    intwhence,
           libewf_error_t**error);

       intlibewf_file_entry_get_offset(libewf_file_entry_t*file_entry, off64_t*offset, libewf_error_t**error);

       intlibewf_file_entry_get_number_of_sub_file_entries(libewf_file_entry_t*file_entry,
           int*number_of_sub_file_entries, libewf_error_t**error);

       intlibewf_file_entry_get_sub_file_entry(libewf_file_entry_t*file_entry,    intsub_file_entry_index,
           libewf_file_entry_t**sub_file_entry, libewf_error_t**error);

       intlibewf_file_entry_get_sub_file_entry_by_utf8_name(libewf_file_entry_t*file_entry,
           constuint8_t*utf8_string,   size_tutf8_string_length,  libewf_file_entry_t**sub_file_entry,
           libewf_error_t**error);

       intlibewf_file_entry_get_sub_file_entry_by_utf8_path(libewf_file_entry_t*file_entry,
           constuint8_t*utf8_string,   size_tutf8_string_length,  libewf_file_entry_t**sub_file_entry,
           libewf_error_t**error);

       intlibewf_file_entry_get_sub_file_entry_by_utf16_name(libewf_file_entry_t*file_entry,
           constuint16_t*utf16_string,  size_tutf16_string_length,  libewf_file_entry_t**sub_file_entry,
           libewf_error_t**error);

       intlibewf_file_entry_get_sub_file_entry_by_utf16_path(libewf_file_entry_t*file_entry,
           constuint16_t*utf16_string,  size_tutf16_string_length,  libewf_file_entry_t**sub_file_entry,
           libewf_error_t**error);