NAME

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

LIBRARY

       library “libewf”

SYNOPSIS

       #include <libewf.h>

       Support functions

       const char *
       libewf_get_version(void);

       int
       libewf_get_access_flags_read();

       int
       libewf_get_access_flags_read_write();

       int
       libewf_get_access_flags_write();

       int
       libewf_get_access_flags_write_resume();

       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(concsh*tafrilenamsei,ze_tilename_lengthu,int8_tormatc,ha*r*filenames[]i,n*tnumber_of_filenamesl,ibewf_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(conwscthar*_tilenamsei,zef_tlename_lengtuhi,nt8f_trmawtc,har*_tfilenames[i*]nn,tumber_of_filenamleisb,ewf_erro*r*_trror);

       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_handle_t *file_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);

       File/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*handlec,hca*ornsftilenames[]i,nntumber_of_filenamesi,natccess_flagsl,ibewf_error_t*error);

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

       ssize_t
       libewf_handle_prepare_read_chunk(l*icbhceuhwnufvksn_o_k*hhibz_aaduebnnnf_cddftfollefvmeereop_,rirt_essiszeed,_ch*uunnksc_obzmuepf_fteesrs,ed_chunk_biusf_ficenocrtmuh_pius_nnitetkzs3_es2ch,e_iudtenn,ctkk8_s_utolm_,fbleawgfs_,e*rerrorro_tssize_t
       libewf_handle_read_chunk(libewf_han**dhclavhenou_intldke_,buscfihfzueenr_,t_buffer_*sniitsz8_e_,tomp*rcevhsoesicedkds,um_buui*fncfthe3ur2n,_t_ch*eiccnhktus8nu_mt_,io_filbaegwsf,_e*r*reorrr_tr);

       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_tbuffer_size,off64_toffsetl,ibewf_error_t*error);

       ssize_t
       libewf_handle_prepare_write_chunk(l*icbhceuhwnufvksn_o_k*hhibz_aaduebonnf_mddftfpllefvreereoe_,rist_sseidz_ec,h*ucnoksm_pbzrueef_ftseerd,_chunk_b*uifsfi_encrto*_mucs_ihitrnuzetnes3k,s2_e_cdthih,enuctnk8ks_utimol,_fbleawgfs_,e*rerrorro_tssize_t
       libewf_handle_write_chunk(libewf_han**dhclavhenou_intldke_,buscfihfzueenr_,t_buffer_dsiaiztzeae_i,tsnsit_z8ce_*,tmcphrveecocsoiksndsesudtm,_buuicfnhftue3nr2k,_tchceihcnuktns8ku_mti,o_filbaegwsf,_e*r*reorrr_tr);

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

       ssize_t
       libewf_handle_write_random(libewf_handle_t*handle,constvoi*dbuffers,ize_tuffer_sizeo,ff64_tffsetl,ibewf_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_hand*lhmeaa_ixtdniltmeu,m_number_of_open_handlliebse,wf_erro*r*_trror);

       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_thandlec,ha*rfilename,size_tfilename_size,libewf_error_t**error);

       int
       libewf_handle_set_segment_filename(libewf_handle_thandlec,onsctha*rfilenames,ize_tilename_lengthl,ibewf_error*_terror);

       int
       libewf_handle_set_maximum_segment_size(libewf_handle_thandles,ize64_tmaximum_segment_sizel,ibewf_error_t*error);

       int
       libewf_handle_set_maximum_segment_size(libewf_handle_t*handles,ize64_taximum_segment_sizel,ibewf_error_t*error);

       int
       libewf_handle_get_delta_segment_filename_size(libewf_handle_thandles,ize_tfilename_size,libewf_error_t**error);

       int
       libewf_handle_get_delta_segment_filename(libewf_handle_thandlec,ha*rfilenames,ize_tilename_sizlei,bewf_error*_terror);

       int
       libewf_handle_set_delta_segment_filename(libewf_handle*_tandlceo,ncsh*tafrilenamsei,zef_tlename_lengtlhi,bewf_error_t*error);

       int
       libewf_handle_get_maximum_delta_segment_size(libewf_handl*eh_tndsliez,e6*4m_tximum_delta_segment_sliizbee,wf_err*o*re_tror);

       int
       libewf_handle_set_maximum_delta_segment_size(libewf_hand*lhea_tdsliez,e6m4a_timum_delta_segment_silzieb,ewf_erro*r*_trror);

       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_tfilename_size,libewf_error_t**error);

       Available when compiled with wide character string support:

       int
       libewf_handle_open_wide(libewf_handle*_tandlwec,hcaor*nf_ittlenames[in]nu,tmber_of_filenamesi,natccess_flagsl,ibewf_error_t*error);

       int
       libewf_handle_get_segment_filename_size_wide(libewf_handle_t*handle,size_t*filename_sizel,ibewf_error_t*error);

       int
       libewf_handle_get_segment_filename_wide(libewf_handle*_tandlwec,har*_tilenamsei,ze_tilename_sizel,ibewf_error_t*error);

       int
       libewf_handle_set_segment_filename_wide(libewf_handle*_tandlceo,nwscthar*_tilenamsei,zef_tlename_lengtlhi,bewf_erro*r*_trror);

       int
       libewf_handle_get_delta_segment_filename_size_wide(libewf_handle*_tandlsei,ze*_tilename_sizel,ibewf_error_t*error);

       int
       libewf_handle_get_delta_segment_filename_wide(libewf_handle*_tandlwec,har*_tilenamsei,zfei_tename_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_set_delta_segment_filename_wide(libewf_handl*eh_tndclowenc,shta*rf_tlenasmiezf,ei_tename_lengltihb,ewf_error*_terror);

       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_thandlew,char_tfilename,size_tfilename_size,libewf_error_t**error);

       Available when compiled with libbfio support:

       int
       libewf_handle_open_file_io_pool(libewf_handle_thandlel,ibbfio_pool_tfile_io_poolia,nctcess_flaglsi,bewf_error*_terror);

       int
       libewf_handle_get_file_io_handle(libewf_handle_thandlel,ibbfio_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_tsectors_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_tbytes_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_thandles,ize32_tchunk_sizel,ibewf_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_terror_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_tcompression_method,libewf_error_t**error);

       int
       libewf_handle_get_compression_values(libewf_handl*eh_tndilnet*,8c_tmpression_levueiln,t*8c_tmpression_flalgisb,ewf_err*o*re_tror);

       int
       libewf_handle_set_compression_values(libewf_handl*eh_tndilnetc,8o_tpression_levueiln,tc8o_tpression_flalgisb,ewf_error*_terror);

       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*_tandluei,nt8*_tajor_versiouni,nt*8m_tnor_versiloinb,ewf_erro*r*_trror);

       int
       libewf_handle_get_segment_file_set_identifier(libewf_handle*_tandluei,nt8*_tet_identifiesri,zes_tzlei,bewf_error*_terror);

       int
       libewf_handle_set_segment_file_set_identifier(libewf_handle*_tandluei,nt8*_tet_identifiesri,zes_tzlei,bewf_error*_terror);

       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,constuint8_t*md5_hash,size_tsize,libewf_error_t**error);

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

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

       int
       libewf_handle_set_read_zero_chunk_on_error(libewf_handle_t*handle,uint8_tzero_on_error,libewf_error_t**error);

       int
       libewf_handle_copy_media_values(libewf_handle*_testination_handllei,bewf_handle*_tource_handllei,bewf_error*_terror);

       int
       libewf_handle_get_number_of_acquiry_errors(libewf_handle_thandleu,int32_tnumber_of_errorsl,ibewf_error_t*error);

       int
       libewf_handle_get_acquiry_error(libewf_handl*eh_tndulien,t3i2n_uteixn,t6*4s_tart_sectuoirn,t6*4n_tmber_of_sectolrisb,ewf_erro*r*_trror);

       int
       libewf_handle_append_acquiry_error(libewf_handl*eh_tndulien,t64s_tart_sectouri,nt64n_tmber_of_sectorlsi,bewf_error*_terror);

       int
       libewf_handle_get_number_of_checksum_errors(libewf_handle_thandleu,int32_tnumber_of_errorsl,ibewf_error*_terror);

       int
       libewf_handle_get_checksum_error(libewf_hand*lhea_tdulien,t3i2n_uteixn,t6*4s_tart_sectuoirn,t6*4n_tmber_of_sectolrisb,ewf_erro*r*_trror);

       int
       libewf_handle_append_checksum_error(libewf_handle*_tandluei,nt64s_tart_sectouri,nt6n4u_tber_of_sectolrisb,ewf_erro*r*_trror);

       int
       libewf_handle_get_number_of_sessions(libewf_handle_thandle,uint32_t*number_of_sessions,libewf_error_t**error);

       int
       libewf_handle_get_session(libewf_handle*_tandluei,nt32i_tdeuxi,nt64*_ttart_sectouri,nt6*4n_tmber_of_sectolrisb,ewf_erro*r*_trror);

       int
       libewf_handle_append_session(libewf_handle*_tandluei,nt64s_tart_sectoru,int64_tumber_of_sectorsl,ibewf_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_handl*eh_tndluei,nt32i_tdeuxi,nt64*_ttart_sectouri,nt64*_tumber_of_sectorlsi,bewf_error*_terror);

       int
       libewf_handle_append_track(libewf_handle_thandleu,int64_ttart_sectoru,int64_tumber_of_sectorsl,ibewf_error*_terror);

       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,intdate_format,libewf_error_t**error);

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

       int
       libewf_handle_get_number_of_header_values(libewf_handle_thandleu,int32_tnumber_of_valuesl,ibewf_error_t**error);

       int
       libewf_handle_get_header_value_identifier_size(libewf_handle*_tandluei,nt32i_tdseixz*,ei_tentifier_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_get_header_value_identifier(libewf_hand*lhea_utdilnet,3i2n_uteixn,t*8i_tentifiseirzi,ed_tntifier_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_get_utf8_header_value_size(libewf_hand*lhea_cutdoilnn*esti,t8d_tntifsiiiezdree,_ttifier_les*niugzttefh_,t_string_siibzeew,f_er*r*oerr_tor);

       int
       libewf_handle_get_utf8_header_value(libewf_han*dhulaci*enoni_ntdtls8eet_,ttisifidizeeenr_,tifier_leuni*gnuttth8f,_t_strsiiunztgef,_t_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_handle_get_utf8_header_value_case_number(libewf_handle_thandluei,nt8*_talusei,zev_tlue_sizlei,bewf_error*_terror);

       int
       libewf_handle_get_utf8_header_value_description(libewf_handle*_tandluei,nt8*_talusei,zev_tlue_sizlei,bewf_error_t*error);

       int
       libewf_handle_get_utf8_header_value_examiner_name(libewf_handle*_tandluei,nt8*_talusei,zev_tlue_sizlei,bewf_erro*r*_trror);

       int
       libewf_handle_get_utf8_header_value_evidence_number(libewf_handl*eh_tndulien,t*8v_tlusei,zev_tlue_sizlei,bewf_error*_terror);

       int
       libewf_handle_get_utf8_header_value_notes(libewf_handle_thandleu,int8_tvalues,ize_talue_sizel,ibewf_error_t*error);

       int
       libewf_handle_get_utf8_header_value_acquiry_date(libewf_handle*_tandluei,nt8*_talusei,zev_tlue_sizlei,bewf_error*_terror);

       int
       libewf_handle_get_utf8_header_value_system_date(libewf_handle_thandluei,nt8*_talusei,zev_tlue_sizlei,bewf_error*_terror);

       int
       libewf_handle_get_utf8_header_value_acquiry_operating_system(libewf_hand*lhea_utdiln*etv,8as_ivtuzaeel,_te_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_get_utf8_header_value_acquiry_software_version(libewf_handl*eh_tndulien*,tv8as_ivtuzaeel,_te_sliizbee,wf_err*o*re_tror);

       int
       libewf_handle_get_utf8_header_value_password(libewf_handle*_tandluei,nt8*_talues,ize_talue_sizel,ibewf_error_t*error);

       int
       libewf_handle_get_utf8_header_value_compression_level(libewf_handle*_tandluei,nt*8v_tlsuiezv,ea_tue_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_set_utf8_header_value(libewf_handl*eh_tndcloenu,sitnt8*_tdentifiecro,nusitnt8*_ttf8_strinsgi,zeu_tf8_string_length);

       int
       libewf_handle_set_utf8_header_value_case_number(libewf_handle*_tandlceo,nusitnt8*_talusei,zvea_tue_lengltihb,ewf_erro*r*_trror);

       int
       libewf_handle_set_utf8_header_value_description(libewf_handl*eh_tndcloueni,sntt8*_talusei,zev_tlue_lengtlhi,bewf_error*_terror);

       int
       libewf_handle_set_utf8_header_value_examiner_name(libewf_handle*_tandlceo,nusitnt*8v_tlsuiezv,ea_tue_lengltihb,ewf_erro*r*_trror);

       int
       libewf_handle_set_utf8_header_value_evidence_number(libewf_handl*eh_tndcloueni,sntt*8v_tlsuiezv,ea_tue_lengltihb,ewf_error*_terror);

       int
       libewf_handle_set_utf8_header_value_notes(libewf_handle_thandlec,onsutint8*_talusei,zev_tlue_lengtlhi,bewf_error*_terror);

       int
       libewf_handle_set_utf8_header_value_acquiry_date(libewf_handl*eh_tndcloueni,sntt*8v_tlusei,zev_tlue_lengtlhi,bewf_error*_terror);

       int
       libewf_handle_set_utf8_header_value_system_date(libewf_handle*_tandlceo,nusitnt8*_talusei,zvea_tue_lengltihb,ewf_erro*r*_trror);

       int
       libewf_handle_set_utf8_header_value_acquiry_operating_system(libewf_hand*lhea_cutdoilnn*estv,t8as_ivtuzaeel,_te_lenlgitbhe,wf_err*o*re_tror);

       int
       libewf_handle_set_utf8_header_value_acquiry_software_version(libewf_hand*lhea_cutdoilnn*estv,t8as_ivtuzaeel,_te_lenlgitbhe,wf_err*o*re_tror);

       int
       libewf_handle_set_utf8_header_value_password(libewf_handle*_tandlceo,nusitnt8*_talusei,zev_tlue_lengtlhi,bewf_error*_terror);

       int
       libewf_handle_set_utf8_header_value_compression_level(libewf_handl*eh_tndcloueni,sntt*8v_tlsuiezv,ea_tue_lengltihb,ewf_err*o*re_tror);

       int
       libewf_handle_set_utf8_header_value_model(libewf_handle*_tandlceo,nusitnt8*_talusei,ze_talue_lengthl,ibewf_error_t*error);

       int
       libewf_handle_set_utf8_header_value_serial_number(libewf_handle*_tandlceo,nusitnt*8v_tlsuiezv,ea_tue_lengltihb,ewf_erro*r*_trror);

       int
       libewf_handle_get_utf16_header_value_size(libewf_han*dhulaci*enoni_ntdtls8eet_,ttisifidizeeenr_,tifier_lensgi*tzuhet,_t16_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_handle_get_utf16_header_value(libewf_han*dhulaci*enoni_ntdtls8eet_,ttisifidizeeenr_,tifier_leunign*ttuh1t,6f_t6_stsuritizfne1g_,t_string_siibzeew,f_er*r*oerr_tor);

       int
       libewf_handle_set_utf16_header_value(libewf_handl*eh_tndcloueni,sntt*8i_tentificeourni,sntt16*_ttf16_strinsgi,zeu_tf16_string_length);

       int
       libewf_handle_copy_header_values(libewf_handle*_testination_handllei,bewf_handle*_tource_handllei,bewf_erro*r*_trror);

       int
       libewf_handle_get_number_of_hash_values(libewf_handle_thandleu,int32_t*number_of_values,libewf_error_t**error);

       int
       libewf_handle_get_hash_value_identifier_size(libewf_handle*_tandluei,nt32i_tdesxi,ze*_tdentifier_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_get_hash_value_identifier(libewf_handl*eh_tndulien,t3i2n_uteixn,t*8i_tentifiseirzi,ed_tntifier_silzieb,ewf_erro*r*_trror);

       int
       libewf_handle_get_utf8_hash_value_size(libewf_hand*lhea_cutdoilnn*esti,t8d_tntifsiiiezdree,_ttifier_lensgi*tzuhet,_t8_string_siibzeew,f_er*r*oerr_tor);

       int
       libewf_handle_get_utf8_hash_value(libewf_han*dhulaci*enoni_ntdtls8eet_,ttisifidizeeenr_,tifier_lenugitn*htu,8t_t8_strsiiunztgef,_t_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_handle_get_utf8_hash_value_md5(libewf_handle_t*handle,uint8_t*value,size_talue_sizel,ibewf_error_t*error);

       int
       libewf_handle_get_utf8_hash_value_sha1(libewf_handle_thandleu,int8_tvalues,ize_tvalue_size,libewf_error_t**error);

       int
       libewf_handle_set_utf8_hash_value(libewf_hand*lhea_cutdoilnn*esti,t8d_tntifsiiidezeren,_tifier_lueci*nonugnttts8fht_,t_stsuritizfne8g_,tstring_lelnigbtehw,f_er*r*oerr_tor);

       int
       libewf_handle_set_utf8_hash_value_md5(libewf_handle*_tandlec,onsutint8_tvalues,ize_talue_lengthl,ibewf_error_t*error);

       int
       libewf_handle_set_utf8_hash_value_sha1(libewf_handle_thandlec,onsutint8_tvalues,ize_talue_lengtlhi,bewf_error*_terror);

       int
       libewf_handle_get_utf16_hash_value_size(libewf_han*dhulaci*enoni_ntdtls8eet_,ttifsiiiezdree,_ttifier_lensgi*tzuhet,_t16_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_handle_get_utf16_hash_value(libewf_hand*lheau_ci*tdonilntdes8e,t_ttisifidizeeenr_,tifier_leunign*ttuh1t,6f_t6_stsuritizfne1g_,t_string_siibzeew,f_er*r*oerr_tor);

       int
       libewf_handle_set_utf16_hash_value(libewf_han*dhulaci*enoni_ntdtls8eet_,ttisifidizeeenr_,tifier_luecinon*gntuts1tht6f,_t6_stsuritizfne1g_,t_string_lelnigbtehw,f_err*o*re_tror);

       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_tfile_entrys,ize_tutf8_string_sizel,ibewf_error_t*error);

       int
       libewf_file_entry_get_utf8_name(libewf_file_entr*yf_tle_enturiyn,t*8u_tf8_strinsgi,zeu_tf8_string_sizlei,bewf_error*_terror);

       int
       libewf_file_entry_get_utf16_name_size(libewf_file_entry_tfile_entrys,ize_tutf16_string_sizlei,bewf_error*_terror);

       int
       libewf_file_entry_get_utf16_name(libewf_file_entr*yf_tle_enturiyn,t1*6u_tf16_strisnigzu,et_t16_string_silzieb,ewf_erro*r*_trror);

       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_tcreation_timel,ibewf_error_t*error);

       int
       libewf_file_entry_get_modification_time(libewf_file_entr*yf_tle_entruyi,nt32*_todification_timlei,bewf_error*_terror);

       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_t_eunitn*rtey3n,2t_ty_modification_tliimbee,wf_err*o*re_tror);

       int
       libewf_file_entry_get_utf8_hash_value_md5(libewf_file_entr*yf_tle_enutirn*ytu,8t_t8_strsiiunztgef,_t_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_file_entry_get_utf16_hash_value_md5(libewf_file_en*tfriyl_t_eunitn*rtuy8t,_t16_strsiiunztgef,_t6_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_file_entry_get_utf8_hash_value_sha1(libewf_file_ent*rfyi_te_enutirn*ytu,8t_t8_strsiiunztgef,_t_string_sliizbee,wf_err*o*re_tror);

       int
       libewf_file_entry_get_utf16_hash_value_sha1(libewf_file_en*tfriyl_t_euni*tnurtty8f,_t6_strsiiunztgef,_t6_string_sliizbee,wf_err*o*re_tror);

       ssize_t
       libewf_file_entry_read_buffer(libewf_file_entry_t*file_entry,void*buffer,size_tbuffer_sizel,ibewf_error_t*error);

       ssize_t
       libewf_file_entry_read_random(libewf_file_entry*_tile_entrvyo*,ibduffesri,zeb_tffer_sizeo,ff64_tffsetl,ibewf_error_t*error);

       off64_t
       libewf_file_entry_seek_offset(libewf_file_entry_t*file_entry,off64_toffset,intwhence,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_en*tfriyl*_nt_eimnnbtterry_,of_sub_file_entlriibeesw,f_err*o*re_tror);

       int
       libewf_file_entry_get_sub_file_entry(libewf_file_en*tfriyls_ut_ei_nnfttirlye,_entry_iinbdeewxf,_file_e*n*tsruyb_tfile_einbterwyf,_e*r*reorrr_tr);

       int
       libewf_file_entry_get_sub_file_entry_by_utf8_name(libewf_f*iulutue*ift_n8sfeit_8nlc8sz_teo_esr_tr_yesitr_tnittgnr,gy_,liebnegwtfh_,file_e*nsturby__tilel_ebnetwrfy_,e*rerrorro_tint
       libewf_file_entry_get_sub_file_entry_by_utf8_path(libewf_file_*efuuniitutlnftrect8fy_8_8_n_i_tnsttzsttretri_ynti,gn,gl_lbeenwgft_hf,ile*_esnutbr_yf_tllei_eenwtf*r_yee,rrrroorr_tint
       libewf_file_entry_get_sub_file_entry_by_utf16_name(libewf_fi*luue*itu_nfteit1fnlc16s1teo6_6r__z_yesttes_tr_ttitrrniygn,,gl_lbeenwgft_hf,ile*_esnutbr_yf_tllei_eenwtfr_ye*,rerrorro_tint
       libewf_file_entry_get_sub_file_entry_by_utf16_path(libewf_fil*euu_ituefnftnit1ftlc16s1reo6_6y__z__sttestntr_titrrniygn,,gl_lbeenwgft_hf,ile*_esnutbr_yf_tllei_eenwtf*r_yee,rrrroorr_t
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 sesssion 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.

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.

ENVIRONMENT
       None

FILES
       None

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  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
       substitude 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 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   to   <joachim.metz@gmail.com>   or   on   the   project   website:
       http://code.google.com/p/libewf/

AUTHOR
       These man pages were written by Joachim Metz.

COPYRIGHT
       Copyright  2006-2013,  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.

SEE ALSO
       the libewf.h include file

libewf                                           March 30, 2013                                        libewf(3)