Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
libewf(3)		    Library Functions Manual		     libewf(3)

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

SYNOPSIS
       #include	<libewf.h>

       Support functions

       const char *
       libewf_get_version(void);

       int
       libewf_get_access_flags_read(void);

       int
       libewf_get_access_flags_read_write(void);

       int
       libewf_get_access_flags_write(void);

       int
       libewf_get_access_flags_write_resume(void);

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

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

       int
       libewf_check_file_signature(const	    char	    *filename,
	   libewf_error_t **error);

       int
       libewf_glob(const     char     *filename,    size_t    filename_length,
	   uint8_t  format,  char  **filenames[],  int	 *number_of_filenames,
	   libewf_error_t **error);

       int
       libewf_glob_free(char	 *filenames[],	   int	  number_of_filenames,
	   libewf_error_t **error);

       Available when compiled with wide character string support:

       int
       libewf_check_file_signature_wide(const	     wchar_t	    *filename,
	   libewf_error_t **error);

       int
       libewf_glob_wide(const	wchar_t	  *filename,  size_t  filename_length,
	   uint8_t format, wchar_t  **filenames[],  int	 *number_of_filenames,
	   libewf_error_t **error);

       int
       libewf_glob_wide_free(wchar_t  *filenames[],  int  number_of_filenames,
	   libewf_error_t **error);

       Available when compiled with libbfio support:

       int
       libewf_check_file_signature_file_io_handle(libbfio_handl*ef_itle_io_handle,
	   libewf_error_t **error);

       Notify functions

       void
       libewf_notify_set_verbose(int verbose);

       int
       libewf_notify_set_stream(FILE *stream, libewf_error_t **error);

       int
       libewf_notify_stream_open(const		   char		    *filename,
	   libewf_error_t **error);

       int
       libewf_notify_stream_close(libewf_error_t **error);

       Error functions

       void
       libewf_error_free(libewf_error_t	**error);

       int
       libewf_error_fprint(libewf_error_t *error, FILE *stream);

       int
       libewf_error_sprint(libewf_error_t *error, char *string,	size_t size);

       int
       libewf_error_backtrace_fprint(libewf_error_t *error, FILE *stream);

       int
       libewf_error_backtrace_sprint(libewf_error_t  *error,   char   *string,
	   size_t size);

       Handle functions

       int
       libewf_handle_initialize(libewf_handle_t			     **handle,
	   libewf_error_t **error);

       int
       libewf_handle_free(libewf_handle_t **handle, libewf_error_t **error);

       int
       libewf_handle_signal_abort(libewf_handle_t		      *handle,
	   libewf_error_t **error);

       int
       libewf_handle_clone(libewf_handle_t		 **destination_handle,
	   libewf_handle_t *source_handle, libewf_error_t **error);

       int
       libewf_handle_open(libewf_handle_t *handle, char	*  const  filenames[],
	   int number_of_filenames, int	access_flags, libewf_error_t **error);

       int
       libewf_handle_close(libewf_handle_t *handle, libewf_error_t **error);

       ssize_t
       libewf_handle_prepare_read_chunk(libewf_handle_t		      *handle,
	   void	       *chunk_buffer,	     size_t	    chunk_buffer_size,
	   void					   *uncompressed_chunk_buffer,
	   size_t   *uncompressed_chunk_buffer_size,   int8_t	is_compressed,
	   uint32_t	   chunk_checksum,	  int8_t       chunk_io_flags,
	   libewf_error_t **error);

       ssize_t
       libewf_handle_read_chunk(libewf_handle_t	*handle,  void	*chunk_buffer,
	   size_t	 chunk_buffer_size,	  int8_t       *is_compressed,
	   void	      *checksum_buffer,	      uint32_t	      *chunk_checksum,
	   int8_t *chunk_io_flags, libewf_error_t **error);

       ssize_t
       libewf_handle_read_buffer(libewf_handle_t    *handle,   void   *buffer,
	   size_t buffer_size, libewf_error_t **error);

       ssize_t
       libewf_handle_read_random(libewf_handle_t   *handle,   void    *buffer,
	   size_t buffer_size, off64_t offset, libewf_error_t **error);

       ssize_t
       libewf_handle_prepare_write_chunk(libewf_handle_t	      *handle,
	   void	       *chunk_buffer,	     size_t	    chunk_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_t
       libewf_handle_write_chunk(libewf_handle_t *handle, void	*chunk_buffer,
	   size_t  chunk_buffer_size,  size_t data_size, int8_t	is_compressed,
	   const    void    *checksum_buffer,	  uint32_t     chunk_checksum,
	   int8_t chunk_io_flags, libewf_error_t **error);

       ssize_t
       libewf_handle_write_buffer(libewf_handle_t *handle, const void *buffer,
	   size_t buffer_size, libewf_error_t **error);

       ssize_t
       libewf_handle_write_random(libewf_handle_t *handle, const void *buffer,
	   size_t buffer_size, off64_t offset, libewf_error_t **error);

       ssize_t
       libewf_handle_write_finalize(libewf_handle_t		      *handle,
	   libewf_error_t **error);

       off64_t
       libewf_handle_seek_offset(libewf_handle_t  *handle,   off64_t   offset,
	   int whence, libewf_error_t **error);

       off64_t
       libewf_handle_get_offset(libewf_handle_t			      *handle,
	   libewf_error_t **error);

       int
       libewf_handle_set_maximum_number_of_open_handles(libewf_handle_t*handle,
	   int maximum_number_of_open_handles, libewf_error_t **error);

       int
       libewf_handle_get_segment_filename_size(libewf_handle_t	      *handle,
	   size_t *filename_size, libewf_error_t **error);

       int
       libewf_handle_get_segment_filename(libewf_handle_t	      *handle,
	   char	*filename, size_t filename_size, libewf_error_t	**error);

       int
       libewf_handle_set_segment_filename(libewf_handle_t	      *handle,
	   const      char	*filename,	 size_t	      filename_length,
	   libewf_error_t **error);

       int
       libewf_handle_set_maximum_segment_size(libewf_handle_t	      *handle,
	   size64_t *maximum_segment_size, libewf_error_t **error);

       int
       libewf_handle_set_maximum_segment_size(libewf_handle_t	      *handle,
	   size64_t maximum_segment_size, libewf_error_t **error);

       int
       libewf_handle_get_delta_segment_filename_size(libewf_handle_t  *handle,
	   size_t *filename_size, libewf_error_t **error);

       int
       libewf_handle_get_delta_segment_filename(libewf_handle_t	      *handle,
	   char	*filename, size_t filename_size, libewf_error_t	**error);

       int
       libewf_handle_set_delta_segment_filename(libewf_handle_t	      *handle,
	   const      char	*filename,	 size_t	      filename_length,
	   libewf_error_t **error);

       int
       libewf_handle_get_maximum_delta_segment_size(libewf_handle_t   *handle,
	   size64_t *maximum_delta_segment_size, libewf_error_t	**error);

       int
       libewf_handle_set_maximum_delta_segment_size(libewf_handle_t   *handle,
	   size64_t maximum_delta_segment_size,	libewf_error_t **error);

       int
       libewf_handle_segment_files_corrupted(libewf_handle_t	      *handle,
	   libewf_error_t **error);

       int
       libewf_handle_segment_files_encrypted(libewf_handle_t	      *handle,
	   libewf_error_t **error);

       int
       libewf_handle_get_filename_size(libewf_handle_t		      *handle,
	   size_t *filename_size, libewf_error_t **error);

       int
       libewf_handle_get_filename(libewf_handle_t  *handle,  char   *filename,
	   size_t filename_size, libewf_error_t	**error);

       Available when compiled with wide character string support:

       int
       libewf_handle_open_wide(libewf_handle_t			      *handle,
	   wchar_t   *	  const	   filenames[],	   int	  number_of_filenames,
	   int access_flags, libewf_error_t **error);

       int
       libewf_handle_get_segment_filename_size_wide(libewf_handle_t   *handle,
	   size_t *filename_size, libewf_error_t **error);

       int
       libewf_handle_get_segment_filename_wide(libewf_handle_t	      *handle,
	   wchar_t *filename, size_t filename_size, libewf_error_t **error);

       int
       libewf_handle_set_segment_filename_wide(libewf_handle_t	      *handle,
	   const     wchar_t	  *filename,	  size_t      filename_length,
	   libewf_error_t **error);

       int
       libewf_handle_get_delta_segment_filename_size_wide(libewf_handle*_htandle,
	   size_t *filename_size, libewf_error_t **error);

       int
       libewf_handle_get_delta_segment_filename_wide(libewf_handle_t  *handle,
	   wchar_t *filename, size_t filename_size, libewf_error_t **error);

       int
       libewf_handle_set_delta_segment_filename_wide(libewf_handle_t  *handle,
	   const     wchar_t	  *filename,	  size_t      filename_length,
	   libewf_error_t **error);

       int
       libewf_handle_get_filename_size_wide(libewf_handle_t	      *handle,
	   size_t *filename_size, libewf_error_t **error);

       int
       libewf_handle_get_filename_wide(libewf_handle_t		      *handle,
	   wchar_t *filename, size_t filename_size, libewf_error_t **error);

       Available when compiled with libbfio support:

       int
       libewf_handle_open_file_io_pool(libewf_handle_t		      *handle,
	   libbfio_pool_t	*file_io_pool,	      int	 access_flags,
	   libewf_error_t **error);

       int
       libewf_handle_get_file_io_handle(libewf_handle_t		      *handle,
	   libbfio_handle_t **file_io_handle, libewf_error_t **error);

       Meta data functions

       int
       libewf_handle_get_sectors_per_chunk(libewf_handle_t	      *handle,
	   uint32_t *sectors_per_chunk,	libewf_error_t **error);

       int
       libewf_handle_set_sectors_per_chunk(libewf_handle_t	      *handle,
	   uint32_t sectors_per_chunk, libewf_error_t **error);

       int
       libewf_handle_get_bytes_per_sector(libewf_handle_t	      *handle,
	   uint32_t *bytes_per_sector, libewf_error_t **error);

       int
       libewf_handle_set_bytes_per_sector(libewf_handle_t	      *handle,
	   uint32_t bytes_per_sector, libewf_error_t **error);

       int
       libewf_handle_get_number_of_sectors(libewf_handle_t	      *handle,
	   uint64_t *number_of_sectors,	libewf_error_t **error);

       int
       libewf_handle_get_chunk_size(libewf_handle_t		      *handle,
	   size32_t	   *chunk_size,	       libewf_error_t	      **error,
	   libewf_error_t **error);

       int
       libewf_handle_get_error_granularity(libewf_handle_t	      *handle,
	   uint32_t *error_granularity,	libewf_error_t **error);

       int
       libewf_handle_set_error_granularity(libewf_handle_t	      *handle,
	   uint32_t error_granularity, libewf_error_t **error);

       int
       libewf_handle_get_compression_method(libewf_handle_t	      *handle,
	   uint16_t *compression_method, libewf_error_t	**error);

       int
       libewf_handle_set_compression_method(libewf_handle_t	      *handle,
	   uint16_t compression_method,	libewf_error_t **error);

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

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

       int
       libewf_handle_get_media_size(libewf_handle_t		      *handle,
	   size64_t *media_size, libewf_error_t	**error);

       int
       libewf_handle_set_media_size(libewf_handle_t		      *handle,
	   size64_t media_size,	libewf_error_t **error);

       int
       libewf_handle_get_media_type(libewf_handle_t		      *handle,
	   uint8_t *media_type,	libewf_error_t **error);

       int
       libewf_handle_set_media_type(libewf_handle_t		      *handle,
	   uint8_t media_type, libewf_error_t **error);

       int
       libewf_handle_get_media_flags(libewf_handle_t		      *handle,
	   uint8_t *media_flags, libewf_error_t	**error);

       int
       libewf_handle_set_media_flags(libewf_handle_t		      *handle,
	   uint8_t media_flags,	libewf_error_t **error);

       int
       libewf_handle_get_format(libewf_handle_t	  *handle,   uint8_t*  format,
	   libewf_error_t **error);

       int
       libewf_handle_set_format(libewf_handle_t	  *handle,   uint8_t   format,
	   libewf_error_t **error);

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

       int
       libewf_handle_get_segment_file_set_identifier(libewf_handle_t  *handle,
	   uint8_t *set_identifier, size_t size, libewf_error_t	**error);

       int
       libewf_handle_set_segment_file_set_identifier(libewf_handle_t  *handle,
	   uint8_t *set_identifier, size_t size, libewf_error_t	**error);

       int
       libewf_handle_get_md5_hash(libewf_handle_t  *handle, uint8_t *md5_hash,
	   size_t size,	libewf_error_t **error);

       int
       libewf_handle_set_md5_hash(libewf_handle_t		      *handle,
	   const uint8_t *md5_hash, size_t size, libewf_error_t	**error);

       int
       libewf_handle_get_sha1_hash(libewf_handle_t		      *handle,
	   uint8_t *sha1_hash, size_t size, libewf_error_t **error);

       int
       libewf_handle_set_sha1_hash(libewf_handle_t		      *handle,
	   const uint8_t *sha1_hash, size_t size, libewf_error_t **error);

       int
       libewf_handle_set_read_zero_chunk_on_error(libewf_handle_t     *handle,
	   uint8_t zero_on_error, libewf_error_t **error);

       int
       libewf_handle_copy_media_values(libewf_handle_t	  *destination_handle,
	   libewf_handle_t *source_handle, libewf_error_t **error);

       int
       libewf_handle_get_number_of_acquiry_errors(libewf_handle_t     *handle,
	   uint32_t *number_of_errors, libewf_error_t **error);

       int
       libewf_handle_get_acquiry_error(libewf_handle_t		      *handle,
	   uint32_t	      index,	      uint64_t		*start_sector,
	   uint64_t *number_of_sectors,	libewf_error_t **error);

       int
       libewf_handle_append_acquiry_error(libewf_handle_t	      *handle,
	   uint64_t	  start_sector,	      uint64_t	    number_of_sectors,
	   libewf_error_t **error);

       int
       libewf_handle_get_number_of_checksum_errors(libewf_handle_t    *handle,
	   uint32_t *number_of_errors, libewf_error_t **error);

       int
       libewf_handle_get_checksum_error(libewf_handle_t		      *handle,
	   uint32_t	     index,	     uint64_t		*start_sector,
	   uint64_t *number_of_sectors,	libewf_error_t **error);

       int
       libewf_handle_append_checksum_error(libewf_handle_t	      *handle,
	   uint64_t	 start_sector,	     uint64_t	    number_of_sectors,
	   libewf_error_t **error);

       int
       libewf_handle_get_number_of_sessions(libewf_handle_t	      *handle,
	   uint32_t *number_of_sessions, libewf_error_t	**error);

       int
       libewf_handle_get_session(libewf_handle_t  *handle,   uint32_t	index,
	   uint64_t	 *start_sector,	     uint64_t	   *number_of_sectors,
	   libewf_error_t **error);

       int
       libewf_handle_append_session(libewf_handle_t		      *handle,
	   uint64_t	  start_sector,	      uint64_t	    number_of_sectors,
	   libewf_error_t **error);

       int
       libewf_handle_get_number_of_tracks(libewf_handle_t	      *handle,
	   uint32_t *number_of_tracks, libewf_error_t **error);

       int
       libewf_handle_get_track(libewf_handle_t	  *handle,   uint32_t	index,
	   uint64_t	 *start_sector,	     uint64_t	   *number_of_sectors,
	   libewf_error_t **error);

       int
       libewf_handle_append_track(libewf_handle_t		      *handle,
	   uint64_t	 start_sector,	     uint64_t	    number_of_sectors,
	   libewf_error_t **error);

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

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

       int
       libewf_handle_get_header_values_data_format(libewf_handle_t    *handle,
	   int date_format, libewf_error_t **error);

       int
       libewf_handle_set_header_values_data_format(libewf_handle_t    *handle,
	   int date_format, libewf_error_t **error);

       int
       libewf_handle_get_number_of_header_values(libewf_handle_t      *handle,
	   uint32_t *number_of_values, libewf_error_t **error);

       int
       libewf_handle_get_header_value_identifier_size(libewf_handle_t *handle,
	   uint32_t index, size_t *identifier_size, libewf_error_t **error);

       int
       libewf_handle_get_header_value_identifier(libewf_handle_t      *handle,
	   uint32_t   index,   uint8_t	*identifier,  size_t  identifier_size,
	   libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_size(libewf_handle_t	      *handle,
	   const     uint8_t	 *identifier,	  size_t    identifier_length,
	   size_t *utf8_string_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value(libewf_handle_t	      *handle,
	   const     uint8_t	 *identifier,	  size_t    identifier_length,
	   uint8_t	  *utf8_string,	       size_t	     utf8_string_size,
	   libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_case_number(libewf_handle_t*handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_description(libewf_handle_t*handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_examiner_name(libewf_handle_*thandle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_evidence_number(libewf_handl*eh_atndle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_notes(libewf_handle_t      *handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_acquiry_date(libewf_handle_t*handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_system_date(libewf_handle_t*handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_acquiry_operating_system(lib*ehwafn_dhlaen,dle_t
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_acquiry_software_version(lib*ehwafn_dhlaen,dle_t
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_password(libewf_handle_t   *handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_header_value_compression_level(libewf_han*dhlaen_dtle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value(libewf_handle_t	      *handle,
	   const    uint8_t    *identifier,    const   uint8_t	 *utf8_string,
	   size_t utf8_string_length);

       int
       libewf_handle_set_utf8_header_value_case_number(libewf_handle_t*handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_description(libewf_handle_t*handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_examiner_name(libewf_handle_*thandle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_evidence_number(libewf_handl*eh_atndle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_notes(libewf_handle_t      *handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_acquiry_date(libewf_handle_t*handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_system_date(libewf_handle_t*handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_acquiry_operating_system(lib*ehwafn_dhlaen,dle_t
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_acquiry_software_version(lib*ehwafn_dhlaen,dle_t
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_password(libewf_handle_t   *handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_compression_level(libewf_han*dhlaen_dtle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_model(libewf_handle_t      *handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_header_value_serial_number(libewf_handle_*thandle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_get_utf16_header_value_size(libewf_handle_t      *handle,
	   const    uint8_t	*identifier,	 size_t	    identifier_length,
	   size_t *utf16_string_size, libewf_error_t **error);

       int
       libewf_handle_get_utf16_header_value(libewf_handle_t	      *handle,
	   const    uint8_t	*identifier,	 size_t	    identifier_length,
	   uint16_t	  *utf16_string,       size_t	    utf16_string_size,
	   libewf_error_t **error);

       int
       libewf_handle_set_utf16_header_value(libewf_handle_t	      *handle,
	   const    uint8_t   *identifier,   const   uint16_t	*utf16_string,
	   size_t utf16_string_length);

       int
       libewf_handle_copy_header_values(libewf_handle_t	  *destination_handle,
	   libewf_handle_t *source_handle, libewf_error_t **error);

       int
       libewf_handle_get_number_of_hash_values(libewf_handle_t	      *handle,
	   uint32_t *number_of_values, libewf_error_t **error);

       int
       libewf_handle_get_hash_value_identifier_size(libewf_handle_t   *handle,
	   uint32_t index, size_t *identifier_size, libewf_error_t **error);

       int
       libewf_handle_get_hash_value_identifier(libewf_handle_t	      *handle,
	   uint32_t  index,  uint8_t  *identifier,   size_t   identifier_size,
	   libewf_error_t **error);

       int
       libewf_handle_get_utf8_hash_value_size(libewf_handle_t	      *handle,
	   const    uint8_t	*identifier,	 size_t	    identifier_length,
	   size_t *utf8_string_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_hash_value(libewf_handle_t	      *handle,
	   const    uint8_t	*identifier,	 size_t	    identifier_length,
	   uint8_t	  *utf8_string,	       size_t	     utf8_string_size,
	   libewf_error_t **error);

       int
       libewf_handle_get_utf8_hash_value_md5(libewf_handle_t	      *handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_get_utf8_hash_value_sha1(libewf_handle_t	      *handle,
	   uint8_t *value, size_t value_size, libewf_error_t **error);

       int
       libewf_handle_set_utf8_hash_value(libewf_handle_t	      *handle,
	   const     uint8_t	 *identifier,	  size_t    identifier_length,
	   const    uint8_t    *utf8_string,	size_t	   utf8_string_length,
	   libewf_error_t **error);

       int
       libewf_handle_set_utf8_hash_value_md5(libewf_handle_t	      *handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_set_utf8_hash_value_sha1(libewf_handle_t	      *handle,
	   const uint8_t *value, size_t	value_length, libewf_error_t **error);

       int
       libewf_handle_get_utf16_hash_value_size(libewf_handle_t	      *handle,
	   const    uint8_t	*identifier,	 size_t	    identifier_length,
	   size_t *utf16_string_size, libewf_error_t **error);

       int
       libewf_handle_get_utf16_hash_value(libewf_handle_t	      *handle,
	   const    uint8_t	*identifier,	 size_t	    identifier_length,
	   uint16_t	  *utf16_string,       size_t	    utf16_string_size,
	   libewf_error_t **error);

       int
       libewf_handle_set_utf16_hash_value(libewf_handle_t	      *handle,
	   const     uint8_t	 *identifier,	  size_t    identifier_length,
	   const   uint16_t   *utf16_string,	size_t	  utf16_string_length,
	   libewf_error_t **error);

       int
       libewf_handle_get_root_file_entry(libewf_handle_t	      *handle,
	   libewf_file_entry_t **root_file_entry, libewf_error_t **error);

       int
       libewf_file_get_file_entry_by_utf8_path(libewf_handle_t	      *handle,
	   const     uint8_t	*utf8_string,	 size_t	   utf8_string_length,
	   libewf_file_entry_t **file_entry, libewf_error_t **error);

       int
       libewf_file_get_file_entry_by_utf16_path(libewf_handle_t	      *handle,
	   const    uint16_t	*utf16_string,	 size_t	  utf16_string_length,
	   libewf_file_entry_t **file_entry, libewf_error_t **error);

       Single file entry functions

       int
       libewf_file_entry_free(libewf_file_entry_t		 **file_entry,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_type(libewf_file_entry_t		  *file_entry,
	   uint8_t *type, libewf_error_t **error);

       int
       libewf_file_entry_get_flags(libewf_file_entry_t		  *file_entry,
	   uint32_t *flags, libewf_error_t **error);

       int();

       libewf_file_entry_get_media_data_offset libewf_file_entry_t *file_entry
       off64_t *media_data_offset libewf_error_t **error
       int();

       libewf_file_entry_get_media_data_size  libewf_file_entry_t  *file_entry
       size64_t	*media_data_size libewf_error_t	**error
       int();

       libewf_file_entry_get_duplicate_media_data_offset   libewf_file_entry_t
       *file_entry off64_t *duplicate_media_data_offset	libewf_error_t **error

       int
       libewf_file_entry_get_utf8_name_size(libewf_file_entry_t	  *file_entry,
	   size_t *utf8_string_size, libewf_error_t **error);

       int
       libewf_file_entry_get_utf8_name(libewf_file_entry_t	  *file_entry,
	   uint8_t	  *utf8_string,	       size_t	     utf8_string_size,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_utf16_name_size(libewf_file_entry_t  *file_entry,
	   size_t *utf16_string_size, libewf_error_t **error);

       int
       libewf_file_entry_get_utf16_name(libewf_file_entry_t	  *file_entry,
	   uint16_t	  *utf16_string,       size_t	    utf16_string_size,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_size(libewf_file_entry_t		  *file_entry,
	   size64_t *size, libewf_error_t **error);

       int
       libewf_file_entry_get_creation_time(libewf_file_entry_t	  *file_entry,
	   uint32_t *creation_time, libewf_error_t **error);

       int
       libewf_file_entry_get_modification_time(libewf_file_entry_t*file_entry,
	   uint32_t *modification_time,	libewf_error_t **error);

       int
       libewf_file_entry_get_access_time(libewf_file_entry_t	  *file_entry,
	   uint32_t *access_time, libewf_error_t **error);

       int
       libewf_file_entry_get_entry_modification_time(libewf_file_en*tfriyl_et_entry,
	   uint32_t *entry_modification_time, libewf_error_t **error);

       int
       libewf_file_entry_get_utf8_hash_value_md5(libewf_file_entry_*tfile_entry,
	   uint8_t	  *utf8_string,	       size_t	     utf8_string_size,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_utf16_hash_value_md5(libewf_file_entry*_ftile_entry,
	   uint8_t	  *utf16_string,       size_t	    utf16_string_size,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_utf8_hash_value_sha1(libewf_file_entry*_ftile_entry,
	   uint8_t	  *utf8_string,	       size_t	     utf8_string_size,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_utf16_hash_value_sha1(libewf_file_entr*yf_itle_entry,
	   uint8_t	  *utf16_string,       size_t	    utf16_string_size,
	   libewf_error_t **error);

       ssize_t
       libewf_file_entry_read_buffer(libewf_file_entry_t	  *file_entry,
	   void	*buffer, size_t	buffer_size, libewf_error_t **error);

       ssize_t
       libewf_file_entry_read_random(libewf_file_entry_t	  *file_entry,
	   void	   *buffer,    size_t	  buffer_size,	   off64_t     offset,
	   libewf_error_t **error);

       off64_t
       libewf_file_entry_seek_offset(libewf_file_entry_t	  *file_entry,
	   off64_t offset, int whence, libewf_error_t **error);

       int
       libewf_file_entry_get_offset(libewf_file_entry_t		  *file_entry,
	   off64_t *offset, libewf_error_t **error);

       int
       libewf_file_entry_get_number_of_sub_file_entries(libewf_file*_feinlter_ye_nttry,
	   int *number_of_sub_file_entries, libewf_error_t **error);

       int
       libewf_file_entry_get_sub_file_entry(libewf_file_entry_t	  *file_entry,
	   int	 sub_file_entry_index,	libewf_file_entry_t  **sub_file_entry,
	   libewf_error_t **error);

       int
       libewf_file_entry_get_sub_file_entry_by_utf8_name(libewf_fil*ef_ielnet_reyn_ttry,
	   const     uint8_t	*utf8_string,	 size_t	   utf8_string_length,
	   libewf_file_entry_t **sub_file_entry, libewf_error_t	**error);

       int
       libewf_file_entry_get_sub_file_entry_by_utf8_path(libewf_fil*ef_ielnet_reyn_ttry,
	   const     uint8_t	*utf8_string,	 size_t	   utf8_string_length,
	   libewf_file_entry_t **sub_file_entry, libewf_error_t	**error);

       int
       libewf_file_entry_get_sub_file_entry_by_utf16_name(libewf_fi*lfei_leen_ternyt_rty,
	   const    uint16_t	*utf16_string,	 size_t	  utf16_string_length,
	   libewf_file_entry_t **sub_file_entry, libewf_error_t	**error);

       int
       libewf_file_entry_get_sub_file_entry_by_utf16_path(libewf_fi*lfei_leen_ternyt_rty,
	   const    uint16_t	*utf16_string,	 size_t	  utf16_string_length,
	   libewf_file_entry_t **sub_file_entry, libewf_error_t	**error);

DESCRIPTION
       The libewf_get_version()	function is used to retrieve the library  ver-
       sion.

       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 ap-
       pend 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	avail-
       able 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.

RETURN VALUES
       Most of the functions return NULL or -1 on error, dependent on the  re-
       turn 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.

ENVIRONMENT
       None

FILES
       None

NOTES
       libewf supports both UTF-8 and UTF-16 encoded strings except for	 file-
       names.	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	 char-
       acter 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 us-
       ing 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 sub-
       stitute 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.

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

AUTHOR
       These man pages were written by Joachim Metz.

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

SEE ALSO
       the libewf.h include file

libewf				August 7, 2022			     libewf(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=libewf&sektion=3&manpath=FreeBSD+Ports+14.3.quarterly>

home | help