NAME

       libfsntfs.h — Library to access the Windows New Technology File System (NTFS) format

LIBRARY

       library “libfsntfs”

SYNOPSIS

       #include <libfsntfs.h>

       Support functions

       const char *
       libfsntfs_get_version(void);

       int
       libfsntfs_get_access_flags_read(void);

       int
       libfsntfs_get_codepage(int *codepage, libfsntfs_error_t **error);

       int
       libfsntfs_set_codepage(int codepage, libfsntfs_error_t **error);

       int
       libfsntfs_check_volume_signature(const char *filename, libfsntfs_error_t **error);

       int
       libfsntfs_check_mft_metadata_file_signature(const char *filename, libfsntfs_error_t **error);

       Available when compiled with wide character string support:

       int
       libfsntfs_check_volume_signature_wide(const wchar_t *filename, libfsntfs_error_t **error);

       int
       libfsntfs_check_mft_metadata_file_signature_wide(const wchar_t *filename, libfsntfs_error_t **error);

       Available when compiled with libbfio support:

       int
       libfsntfs_check_volume_signature_file_io_handle(libbfio_handle_t*file_io_handle,libfsntfs_error_t**error);

       int
       libfsntfs_check_mft_metadata_file_signature_file_io_handle(libbfio_handl*ef_tle_io_handllieb,fsntfs_erro*r*_trror);

       Notify functions

       void
       libfsntfs_notify_set_verbose(int verbose);

       int
       libfsntfs_notify_set_stream(FILE *stream, libfsntfs_error_t **error);

       int
       libfsntfs_notify_stream_open(const char *filename, libfsntfs_error_t **error);

       int
       libfsntfs_notify_stream_close(libfsntfs_error_t **error);

       Error functions

       void
       libfsntfs_error_free(libfsntfs_error_t **error);

       int
       libfsntfs_error_fprint(libfsntfs_error_t *error, FILE *stream);

       int
       libfsntfs_error_sprint(libfsntfs_error_t *error, char *string, size_t size);

       int
       libfsntfs_error_backtrace_fprint(libfsntfs_error_t *error, FILE *stream);

       int
       libfsntfs_error_backtrace_sprint(libfsntfs_error_t *error, char *string, size_t size);

       Volume functions

       int
       libfsntfs_volume_initialize(libfsntfs_volume_t **volume, libfsntfs_error_t **error);

       int
       libfsntfs_volume_free(libfsntfs_volume_t **volume, libfsntfs_error_t **error);

       int
       libfsntfs_volume_signal_abort(libfsntfs_volume_t *volume, libfsntfs_error_t **error);

       int
       libfsntfs_volume_open(libfsntfs_volume_t*volume,constchar*filename,intaccess_flags,libfsntfs_error_t**error);

       int
       libfsntfs_volume_close(libfsntfs_volume_t *volume, libfsntfs_error_t **error);

       int
       libfsntfs_volume_has_bitlocker_drive_encryption(libfsntfs_volume_t *volume, libfsntfs_error_t **error);

       int
       libfsntfs_volume_has_volume_shadow_snapshots(libfsntfs_volume_t *volume, libfsntfs_error_t **error);

       int
       libfsntfs_volume_get_cluster_block_size(libfsntfs_volume_tvolumes,ize*_tluster_block_sizlei,bfsntfs_error*_terror);

       int
       libfsntfs_volume_get_mft_entry_size(libfsntfs_volume_tvolumes,ize32_t*mft_entry_size,libfsntfs_error_t**error);

       int
       libfsntfs_volume_get_index_entry_size(libfsntfs_volume_tvolumes,ize32_tindex_entry_sizel,ibfsntfs_error*_terror);

       int
       libfsntfs_volume_get_utf8_name_size(libfsntfs_volume_t*volume,size_t*utf8_name_size,libfsntfs_error_t**error);

       int
       libfsntfs_volume_get_utf8_name(libfsntfs_volume_tvolumeu,int8_tutf8_names,izeu_tf8_name_sizlei,bfsntfs_error*_terror);

       int
       libfsntfs_volume_get_utf16_name_size(libfsntfs_volume_tvolumes,ize_t*utf16_name_size,libfsntfs_error_t**error);

       int
       libfsntfs_volume_get_utf16_name(libfsntfs_volume*_tolumuei,nt16*_ttf16_namsei,zeu_tf16_name_sizlei,bfsntfs_error*_terror);

       int
       libfsntfs_volume_get_version(libfsntfs_volume*_tolumuei,nt8*_tajor_versiouni,nt8*_tinor_versiolni,bfsntfs_error_t*error);

       int
       libfsntfs_volume_get_serial_number(libfsntfs_volume_t*volume,uint64_t*serial_number,libfsntfs_error_t**error);

       int
       libfsntfs_volume_get_number_of_file_entries(libfsntfs_volu*mveo_utuimnet*,6n4u_tber_of_file_entrileisb,fsntfs_erro*r*_trror);

       int
       libfsntfs_volume_get_file_entry_by_index(libfsntfs_vol*uvmouelim_nftmtte6_,4e_ttry_iinbdfesxn,tfs_file_e*n*tfriyl_t_einbtfrsyn,tfs_e*r*reorrr_tr);

       int
       libfsntfs_volume_get_root_directory(libfsntfs_volum*ev_tlulmieb,fsntfs_file_entr*y*_tile_entrlyi,bfsntfs_error*_terror);

       int
       libfsntfs_volume_get_file_entry_by_utf8_path(libfsntfs_vuuo*itlvcnfuuoot8tmln8_feus_i8_tttz_teres,i_ntrgi,ng_liebnfgstnht,fs_file_e*nftirlyel_tebnftsrnyt,fs_e*rerrorro_tint
       libfsntfs_volume_get_file_entry_by_utf16_path(libfsntu*fiusnt_ctfvvo11uoon66tlls_fuuttsi1mmtz6eere__i_tnttgr,ing_liebnfgstnht,fs_file_e*nftirlyel_tebnftsrnyt,fs_e*rerrorro_tint
       libfsntfs_volume_open_wide(libfsntfs_volume_t*volume,constwchar_t*filenamei,natccess_flagsl,ibfsntfs_error_t*error);

       Available when compiled with libbfio support:

       int
       libfsntfs_volume_open_file_io_handle(libfsntfs_volu*mveo_ltuimbeb,fio_hand*lfei_te_io_haanicdncltees,s_flalgisb,fsntfs_erro*r*_trror);

       File entry functions

       int
       libfsntfs_file_entry_free(libfsntfs_file_entry_t **file_entry, libfsntfs_error_t **error);

       int
       libfsntfs_file_entry_is_empty(libfsntfs_file_entry_t *file_entry, libfsntfs_error_t **error);

       int
       libfsntfs_file_entry_is_allocated(libfsntfs_file_entry_t *file_entry, libfsntfs_error_t **error);

       int
       libfsntfs_file_entry_get_file_reference(libfsntfs_file_entry*_tile_enturiyn,t6*4f_tle_referenlcieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_base_record_file_reference(libfsntfs_file_e*nftirlye_teunitn*rtfy6i,4l_t_referleinbcfes,ntfs_er*r*oerr_tor);

       int
       libfsntfs_file_entry_get_parent_file_reference(libfsntfs_file_ent*rfyi_te_enutirnyt*,6f4i_te_referelnicbef,sntfs_er*r*oerr_tor);

       int
       libfsntfs_file_entry_get_parent_file_reference_by_attribute_index(libfsntfs_ftitl*refi_beliu*nentuft_eiire_lynite_n6_trd4rye_l,xtfi,ebrfesnnctef,s*_eerrrroorr_tint
       libfsntfs_file_entry_get_journal_sequence_number(libfsntfs_file_e*nftirlye_tei*nnjttor6uy4r,_tal_sequence_niubmfbsenrt,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_creation_time(libfsntfs_file_entry*_tile_entruyi,nt64_tfiletimel,ibfsntfs_error_t*error);

       int
       libfsntfs_file_entry_get_modification_time(libfsntfs_file_entry*_tile_entruyi,nt64*_tiletimlei,bfsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_access_time(libfsntfs_file_entry_tfile_entryu,int64_tfiletimel,ibfsntfs_error_t*error);

       int
       libfsntfs_file_entry_get_entry_modification_time(libfsntfs_file_entr*yf_tle_enturiyn,t6*4f_tletliimbef,sntfs_err*o*re_tror);

       int
       libfsntfs_file_entry_get_file_attribute_flags(libfsntfs_file_e*nftirlye_teunitn*rtfy3i,2l_t_attribute_flliabgfss,ntfs_er*r*oerr_tor);

       int
       libfsntfs_file_entry_get_utf8_name_size(libfsntfs_file_entry*_tile_entrsyi,ze*_ttf8_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_utf8_name(libfsntfs_file_ent*rfyi_te_enturiyn,t*8u_tf8_nasmiezu,et_t8_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_utf16_name_size(libfsntfs_file_entry*_tile_entsriyz*,eu_tf16_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_utf16_name(libfsntfs_file_ent*rfyi_te_enutirnyt*,1u6t_t16_nsaiumzteef,_t6_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_name_attribute_index(libfsntfs_file_entr*yf_tle_en*tiarntytt,ribute_indleixb,fsntfs_err*o*re_tror);

       int
       libfsntfs_file_entry_get_utf8_name_size_by_attribute_index(libfsntfs_filea_teftnirtlireiby_u*_ttutnestt_friz8yne_,d_etaxml,ei_sfisznet,fs_e*r*reorrr_tr);

       int
       libfsntfs_file_entry_get_utf8_name_by_attribute_index(libfsntfs_file_e*nfatitrltyer_itenbntuttrey_*,iiuunnttdtfsfe88i8x__,tnena_mtmleei,_sfisznet,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_utf16_name_size_by_attribute_index(libfsntfs_filae*t_teirnliteibr_u*yettu_esttt_friz1yne6,d_etnxa,mlei_sfisznet,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_utf16_name_by_attribute_index(libfsntfs_file_e*tnfttirrliyeib_utettneu*t_urintuyntft,d11sfe66i1x_6,tne_a_mtaeml,ei_sfisznet,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_utf8_reparse_point_substitute_name_size(libfsntfs_file*_*eiunlstteifr_8yee___tttarmlyei,_sfisznet,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_utf8_reparse_point_substitute_name(libfsntfs_file_e*nftirlye*_uuteittnnfsftt8i8r8__y_en,ta_mtmleei,_sfisznet,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_utf16_reparse_point_substitute_name_size(libfsntfs_file**_ueitnlsftei1r_6yee___tttalrmiyeb,_ssinztef,s_e*rerrorro_tint
       libfsntfs_file_entry_get_utf16_reparse_point_substitute_name(libfsntfs_file_efnitlreu*y_u_ntutntftt11sfr66i1y_6,tne_a_mtalemi,eb_ssinztef,s*_eerrrroorr_tint
       libfsntfs_file_entry_get_utf8_reparse_point_print_name_size(libfsntfs_file_efnitl*resuy_t_zftne8t_rtnya,mel_sbifzsen,tfs_e*r*reorrr_tr);

       int
       libfsntfs_file_entry_get_utf8_reparse_point_print_name(libfsntfs_file_e*nftirlye_*teiunntttfur88sty_f,tnz8ae_m_eta,mel_sbifzsen,tfs_e*r*reorrr_tr);

       int
       libfsntfs_file_entry_get_utf16_reparse_point_print_name_size(libfsntfs_file_efni*tluresty_f_z1tne6t_rtnya,mlei_sfisznet,fs_e*r*reorrr_tr);

       int
       libfsntfs_file_entry_get_utf16_reparse_point_print_name(libfsntfs_file_e*nftirlye_tei*nnutttur1fty61sf,_i1t_6ne_a_mtaeml,ei_sfisznet,fs_e*rerrorro_tint
       libfsntfs_file_entry_get_security_descriptor_size(libfsntfs_file_ent*rfyi_te_enstirz*yed,_tta_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_security_descriptor(libfsntfs_file_entr*yf_tle_enturiyn,t*8d_sttiazd,ea_ta_silzieb,fsntfs_err*o*re_tror);

       int
       libfsntfs_file_entry_get_number_of_attributes(libfsntfs_file_en*tfriyl_t_enniutnmrtbye,r_of_attribultiebsf,sntfs_err*o*re_tror);

       int
       libfsntfs_file_entry_get_attribute_by_index(libfsntfs_file_e*nfatitrltyer_itenbntuttrey_,iinbdfesxn,tfs_attri*b*uattetl_itibbfustnet,fs_e*rerrorro_tint
       libfsntfs_file_entry_has_directory_entries_index(libfsntfs_file_entry_tfile_entry,libfsntfs_error_t**error);

       int
       libfsntfs_file_entry_has_default_data_stream(libfsntfs_file_entry_t*file_entry,libfsntfs_error_t**error);

       int
       libfsntfs_file_entry_get_number_of_alternate_data_streams(libfsntf*sn_fmibl*eefr_i_elnonetft_reaynl_ttreyr,nate_datal_sbtfrsenatmf*ss*,_errrroorr_t

       int
       libfsntfs_file_entry_get_alternate_data_stream_by_index(lailbtfesrnntaftse_f*idifnalittela__e_lnetitnrbrtefyras_mnt,_ifnsd_ed*xa*,taal_setrrneaatme_tdiabtfas*_*stetfrrsre_aermr,ror_t

       int
       libfsntfs_file_entry_has_alternate_data_stream_by_utf8_name(libfsntfs_file**_uueiitnlnfutect8tr_8_fyen_i8_sttz_tttresri_yntr,gi,ng_liebnfgstnht,fs_e*rerrorro_tint
       libfsntfs_file_entry_has_alternate_data_stream_by_utf16_name(libfsntfs_file_*efuuniitutlnftrect1fy_16s1_n6_6tns_z_ttttesrr_yitr,nign,gl_lbefnsgntthf,s*_eerrrroorr_tint
       libfsntfs_file_entry_get_alternate_data_stream_by_utf8_namuetfl*8iu_btssffitsu8zrni_iltns_iftttgbs8r__lsf*ctnenifogntlin,gfelsts_th_e_dneatnt*rta*yr__slt,ttreeranma_te_daltiab_sstnrt*ef*asem_,errorror_t

       int
       libfsntfs_file_entry_get_alternate_data_stream_by_utf16_nameultifb1f*6su_ntsstufitfi1zrlsn6eii__bf1stgfi*6t_lfc_lneiotiet_nnnfeesggsn_,t_tehdrn,a*ytt*_aaty_,stterrenaamt_t_dlaitbaf_sn*tt*rfeesra_meo,rrror_t

       int
       libfsntfs_file_entry_get_number_of_sub_file_entries(libfsntfs_file*_nefunimtlbreiey_r_t_tnotfr_ys,ub_file_enltirbifessn,tfs_e*r*reorrr_tr);

       int
       libfsntfs_file_entry_get_sub_file_entry_by_index(libfsntfs_fsiulbe*__feiinliltener__yee_ntttlrriyyb,_isnndtefxs,_fil*e*_eunbt_rfyil_iteb_esnnttrf*ys*,_errrroorr_t

       int
       libfsntfs_file_entry_get_sub_file_entry_by_utf8_name(libfsnut*tfufst8_fs_fi8isin_tl*tseref8t__c_tnlelotiginenn_t_glfret,esynnn_gttrtfyhs,,_file*_esnutbr_yf_tllei_efnstnrtyf,s*_eerrrroorr_tint
       libfsntfs_file_entry_get_sub_file_entry_by_utf16_name(libfsntf*usut_tffif1in1s6l*t6i_ef1_s_c6setelo__nentrtit_inlretngiyng__,lftresynn,gttfhs,_fil*e*_eunbt_rfyil_iteb_esnntt*rf*yse,_errorror_t

       ssize_t
       libfsntfs_file_entry_read_buffer(libfsntfs_file_entry*_tile_entrvyo*,ibduffesri,ze_tuffer_sizel,ibfsntfs_error_t*error);

       ssize_t
       libfsntfs_file_entry_read_buffer_at_offset(libfsntfs_file_entr*yf_tle_entv*robyiu,dfsfibezuref,_ter_soifzfoe6f,4fl_itebtf,sntfs_err*o*re_tror);

       off64_t
       libfsntfs_file_entry_seek_offset(libfsntfs_file_entry_tfile_entryo,ff64_tffseti,nwthence,libfsntfs_error_t**error);

       int
       libfsntfs_file_entry_get_offset(libfsntfs_file_entry_t*file_entry,off64_t*offset,libfsntfs_error_t**error);

       int
       libfsntfs_file_entry_get_size(libfsntfs_file_entry_t*file_entry,size64_t*size,libfsntfs_error_t **error);

       int
       libfsntfs_file_entry_get_number_of_extents(libfsntfs_file_entr*yf_tle_en*tinrnuytm,ber_of_extenltisb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_entry_get_extent_by_index(libfsntfs_file_e*nfetixrltyee_ntentnt_*tifernfxyd6t,e4ex_,tt_osfi*fzesexe6tt4e,_ttu_*sneitxz3te2e,_tt_filbafgssn,tfs_e*r*reorrr_tr);

       Attribute functions

       int
       libfsntfs_attribute_free(libfsntfs_attribute_t **attribute, libfsntfs_error_t **error);

       int
       libfsntfs_attribute_get_type(libfsntfs_attribute_t *attribute, uint32_t *type, libfsntfs_error_t**error);

       int
       libfsntfs_attribute_get_data_flags(libfsntfs_attribute_tattributeu,int16_tdata_flags,libfsntfs_error_t**error);

       int
       libfsntfs_attribute_get_utf8_name_size(libfsntfs_attribute_tattributsei,ze*_ttf8_name_sizlei,bfsntfs_error*_terror);

       int
       libfsntfs_attribute_get_utf8_name(libfsntfs_attribut*ea_ttribuutien,t*8u_tf8_nasmiezu,et_t8_name_sizlei,bfsntfs_error*_terror);

       int
       libfsntfs_attribute_get_utf16_name_size(libfsntfs_attribute*_tttributsei,ze*_ttf16_name_sizlei,bfsntfs_erro*r*_trror);

       int
       libfsntfs_attribute_get_utf16_name(libfsntfs_attribu*taet_tribuuitnet,1*6u_tf16_nasmiezu,et_t16_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_attribute_get_data_vcn_range(libfsntfs_attribu*taet_tribuuitnet*,6d4a_ta_firstu_vn*ctdn6a,4t_t_lastl_vbcfns,ntfs_er*r*oerr_tor);

       int
       libfsntfs_attribute_get_file_reference(libfsntfs_attrib*uattet_tiubiun*ttme6f,4t_tentry_iunidn*etsx1e,6q_tence_nulmibbefrs,ntfs_er*r*oerr_tor);

       int
       libfsntfs_attribute_get_data_size(libfsntfs_attribute_t*attribute,size64_t*data_size,libfsntfs_error_t*error);

       $FILE_NAME attribute functions

       int
       libfsntfs_file_name_attribute_get_parent_file_reference(libfsntfs_attr*iabtutu*tripeina_trtu6et4ne_,t_file_refleirbefnscnet,fs_e*rerrorro_tint
       libfsntfs_file_name_attribute_get_creation_time(libfsntfs_attribute*_tttribuutien,t6*4f_tletilmieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_name_attribute_get_modification_time(libfsntfs_attribu*taet_tribuuitnet*,6f4i_tetilmieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_name_attribute_get_access_time(libfsntfs_attribute*_tttributuei,nt64*_tiletilmieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_file_name_attribute_get_entry_modification_time(libfsntfs_attrib*uattet_tiubiun*ttfe6i,4l_lttiibmfes,ntfs_err*o*re_tror);

       int
       libfsntfs_file_name_attribute_get_file_attribute_flags(libfsntfs_attri*bauttteru*_iftbniutlt3ee2_,_tttributel_fblfasgnst,fs_e*rerrorro_tint
       libfsntfs_file_name_attribute_get_utf8_name_size(libfsntfs_attribu*taet_tribsui*tzueet,_t8_name_sliizbef,sntfs_erro*r*_trror);

       int
       libfsntfs_file_name_attribute_get_utf8_name(libfsntfs_attribu*taet_tribuuitn*etu,8t_t8_nsaiumzteef,_t_name_sliizbef,sntfs_er*r*oerr_tor);

       int
       libfsntfs_file_name_attribute_get_utf16_name_size(libfsntfs_attrib*uattet_tibsui*tzueet,_t16_name_sliizbef,sntfs_err*o*re_tror);

       int
       libfsntfs_file_name_attribute_get_utf16_name(libfsntfs_attribu*taet_tribuuitn*etu,1t6f_t6_unitazfme1e_,t_name_siibzfes,ntfs_er*r*oerr_tor);

       $REPARSE_POINT attribute functions

       int
       libfsntfs_reparse_point_attribute_get_tag(libfsntfs_attribute_tattributeu,int32_ttag,libfsntfs_error_t**error);

       $SECURITY_DESCRIPTOR attribute functions

       int
       libfsntfs_security_descriptor_attribute_get_security_descriptor_size(libfsntfs_attri*ba*utdttsaeritl_zaitbe_u_fttisezn,et,fs_e*rerrorro_tint
       libfsntfs_security_descriptor_attribute_get_security_descriptor(libfsntfs_attri*bautttsderu*ia_idzttbnaeautt_t8atsie_ib,tzfes,ntfs_er*r*oerr_tor);

       $STANDARD_INFORMATION attribute functions

       int
       libfsntfs_standard_information_attribute_get_creation_time(libfsntfs_attrib*uattet_tiubiun*ttfe6i,4l_lttiibmfes,ntfs_er*r*oerr_tor);

       int
       libfsntfs_standard_information_attribute_get_modification_time(libfsntfs_attri*bauttteru_i*tbnfutit6lle4ei,_btifmsen,tfs_er*r*oerr_tor);

       int
       libfsntfs_standard_information_attribute_get_access_time(libfsntfs_attribu*taet_tribuuitn*etf,6i4l_lttiibmfes,ntfs_er*r*oerr_tor);

       int
       libfsntfs_standard_information_attribute_get_entry_modification_time(libfsntfs_attr*iabtutu*trifeinil_tlitu6ebt4tfe_s,tmnet,fs_e*rerrorro_tint
       libfsntfs_standard_information_attribute_get_file_attribute_flags(libfsntfs_at*t*frauiitilbtneurt_ti3aeb2t__tttrei,bultieb_fslnatgf*ss*,_errrroorr_t

       int
       libfsntfs_standard_information_attribute_get_owner_identifier(libfsntfs_att*raitbtu*uriotinwebtn_3ett2re_,tidenltiibffisenrt,fs_e*rerrorro_tint
       libfsntfs_standard_information_attribute_get_security_descriptor_identifier*lsiebcfusrnuititfnys*t__3dat2ett_trtcriribibuputtteole,ri_tif*ds*enentrtfrisof_ieerrr,or_t

       int
       libfsntfs_standard_information_attribute_get_update_sequence_number(libfsntf*su_a*udtaiattntrtteir6_bi4sub_tutqetu_et,nclei_nfusmnbtef*rs*,_errrroorr_t

       $VOLUME_INFORMATION attribute functions

       int
       libfsntfs_volume_information_attribute_get_version(libfsntfs_attrib*uattet_u*tiimbnautjt8oe_,t_veu*rimsniitno8on_,t_velrisbifosnn,tfs_e*r*reorrr_tr);

       int
       libfsntfs_volume_information_attribute_get_flags(libfsntfs_attribut*ea_ttribuutien,t16*_tlaglsi,bfsntfs_error*_terror);

       $VOLUME_NAME attribute functions

       int
       libfsntfs_volume_name_attribute_get_utf8_name_size(libfsntfs_attribu*taet_tribsui*tzueet,_t8_name_sliizbef,sntfs_er*r*oerr_tor);

       int
       libfsntfs_volume_name_attribute_get_utf8_name(libfsntfs_attrib*uattet_tiubi*unuttte8f,_t_nsaiumzteef,_t_name_sliizbef,sntfs_err*o*re_tror);

       int
       libfsntfs_volume_name_attribute_get_utf16_name_size(libfsntfs_attribu*taet_tribs*uiutzteef,_t6_name_siibzfes,ntfs_er*r*oerr_tor);

       int
       libfsntfs_volume_name_attribute_get_utf16_name(libfsntfs_attrib*uattet_tiubiun*ttue1t,6f_t6_unitazfme1e_,t_name_siibzfes,ntfs_er*r*oerr_tor);

       int
       libfsntfs_volume_get_usn_change_journal(libfsntfs_vo*lvluoimlbeuf_sten,tfs_usn_change_jo*u*runsanl__thange_jloiubrfnsanlt,fs_e*rerrorro_tint
       libfsntfs_data_stream_free(libfsntfs_data_stream_t **data_stream, libfsntfs_error_t **error);

       int
       libfsntfs_data_stream_get_utf8_name_size(libfsntfs_data_strea*md_tta_stresaimz*,eu_tf8_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_data_stream_get_utf8_name(libfsntfs_data_strea*md_tta_streuaimn,t*8u_tf8_nsaiumzteef,_t_name_sliizbef,sntfs_err*o*re_tror);

       int
       libfsntfs_data_stream_get_utf16_name_size(libfsntfs_data_stre*adma_ta_strseiaz*meu,_tf16_name_silzieb,fsntfs_erro*r*_trror);

       int
       libfsntfs_data_stream_get_utf16_name(libfsntfs_data_stre*adma_ta_strueianmt*,1u6t_t16_nsaiumzteef,_t6_name_sliizbef,sntfs_er*r*oerr_tor);

       ssize_t
       libfsntfs_data_stream_read_buffer(libfsntfs_data_stream*_tata_streavmo*,ibduffesri,zeb_tffer_sizlei,bfsntfs_error*_terror);

       ssize_t
       libfsntfs_data_stream_read_buffer_at_offset(libfsntfs_data_stre*adma_ta_st*rvbeouaifsmdfib,ezuref,_ter_soifzfoe6f,4fl_itebtf,sntfs_err*o*re_tror);

       off64_t
       libfsntfs_data_stream_seek_offset(libfsntfs_data_stream*_tata_streamo,ff64_tffseti,nwthencel,ibfsntfs_error_t*error);

       int
       libfsntfs_data_stream_get_offset(libfsntfs_data_stream_t*data_stream,off64_t*offset,libfsntfs_error_t**error);

       int
       libfsntfs_data_stream_get_size(libfsntfs_data_stream_t*data_stream,size64_t*size,libfsntfs_error_t**error);

       int
       libfsntfs_data_stream_get_number_of_extents(libfsntfs_data_strea*md_tta_st*rneiuanmmtb,er_of_extelnitbsf,sntfs_err*o*re_tror);

       int
       libfsntfs_data_stream_get_extent_by_index(libfsntfs_data_s*etdxrateteaanm_t_n_*tttifernfxed6tae4emx_,,tt_osfi*fzesexe6tt4e,_ttu_*sneitxz3te2e,_tt_filbafgssn,tfs_e*r*reorrr_tr);

       MFT metadata file functions

       int
       libfsntfs_mft_metadata_file_initialize(libfsntfs_mft_metadata_file*_tmft_metadata_fillei,bfsntfs_error*_terror);

       int
       libfsntfs_mft_metadata_file_free(libfsntfs_mft_metadata_file_t**mft_metadata_file,libfsntfs_error_t**error);

       int
       libfsntfs_mft_metadata_file_open(libfsntfs_mft_metadata_fil*em_tt_metadata_fic*locfenhi,salatrecnicanemtses,_fllaigbsf,sntfs_err*o*re_tror);

       int
       libfsntfs_mft_metadata_file_close(libfsntfs_mft_metadata_file_t*mft_metadata_file,libfsntfs_error_t**error);

       int
       libfsntfs_mft_metadata_file_get_utf8_volume_name_size(libfsntfs_mft_metada*tmaf_f_im*leuett_ftds8ai_tzvaeo_ftuimlee_,niabmfes_st*if*zsee_,errorror_t

       int
       libfsntfs_mft_metadata_file_get_utf8_volume_name(libfsntfs_mft_metad*amtfat_fmie*ltueat_uftai8utn_atvf_o8f_s_ituivlmzoeeel,_ntmaem_enl,aimbef_snitzf*es*,_errrroorr_t

       int
       libfsntfs_mft_metadata_file_get_utf16_volume_name_size(libfsntfs_mft_metada*tmaf_*f_imtlefet1_s6tdi_azvteoa__ufmiel_eni,abmfes_st*if*zsee_,errorror_t

       int
       libfsntfs_mft_metadata_file_get_utf16_volume_name(libfsntfs_mft_metad*amtfat_fm*ieultteaufu_i1ttan6ftt_a1v6_os_f_ivituzolmelee_,_mnea_mnleai,mbef_snitzf*es*,_errrroorr_t

       int
       libfsntfs_mft_metadata_file_get_volume_version(libfsntfs_mft_metadata*_ffitl_em_ttada*tumaia_jfto*i8rml_ietvin,enortrs8_i_iotebnrf,ssinotnf,s*_eerrrroorr_tint
       libfsntfs_mft_metadata_file_get_number_of_file_entries(libfsntfs_mft_meta*dmaftta__*fenitulaumedib_netttra6__of_it_lfei,llei_efnstnrt*if*eses_,errorror_t

       int
       libfsntfs_mft_metadata_file_get_file_entry_by_index(libfsntfs_mft_metad*amtfat_fmmiefltteau__ietannltttia6rb_yff_itinlntedf,esx_,f*i*llfieib_feesn_*tet*rnfeytsr__tyeo,rrror_t

       Available when compiled with wide character string support:

       int
       libfsntfs_mft_metadata_file_open_wide(libfsntfs_mft_metadata_f*imlfet_tmetadataw_c*fohfinaialsrlcet_ic,tnneatsmse_,fllaigbsf,sntfs_err*o*re_tror);

       Available when compiled with libbfio support:

       int
       libfsntfs_mft_metadata_file_open_file_io_handle(libfsntfs_mft_metadat*am_fti_lmee_tadaltiab_ffiiloe_,hfaaicnlcdeell_ieisb_i_t_fshtlnaatngf*dss*l,_eer,rrroorr_t

       USN change journal functions

       int
       libfsntfs_usn_change_journal_free(libfsntfs_usn_change_journal_t*usn_change_journall,ibfsntfs_error_t*error);

       int
       libfsntfs_usn_change_journal_get_offset(libfsntfs_usn_change_journ*auls_t_change_jouronfaf*l6o,4f_ltsiebtf,sntfs_er*r*oerr_tor);

       ssize_t
       libfsntfs_usn_change_journal_read_usn_record(libfsntfs_usn_change_juosunr_ncahla*_utgseun__jnrsotenu8cs_r_irntrzeadecl_,dtradt_ad,altiab_ssinztef,s*_eerrrroorr_t
DESCRIPTION
       The libfsntfs_get_version() function is used to retrieve the library version.

RETURN VALUES
       Most of the functions return NULL or -1 on error, dependent on the return type.  For  the  actual  return
       values see "libfsntfs.h".

ENVIRONMENT
       None

FILES
       None

NOTES
       libfsntfs allows to be compiled with wide character support (wchar_t).

       To compile libfsntfs with wide character support use: ./configure --enable-wide-character-type=yes
        or define: _UNICODE
        or UNICODE
        during compilation.

       LIBFSNTFS_WIDE_CHARACTER_TYPE
        in libfsntfs/features.h can be used to determine if libfsntfs was compiled with wide character support.

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

AUTHOR
       These man pages are generated from "libfsntfs.h".

COPYRIGHT
       Copyright (C) 2010-2019, 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 libfsntfs.h include file

libfsntfs                                        April 20, 2018                                     libfsntfs(3)