libsmdev.h — Library to access and read storage media (SM) devices

       These man pages are generated from "libsmdev.h".

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

       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.

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

       None

       None

       libsmdev.h — Library to access and read storage media (SM) devices

       libsmdev can be compiled with wide character support (wchar_t).

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

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

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

       the libsmdev.h include file

libsmdev                                         March 10, 2019                                      libsmdev(3)

#include<libsmdev.h>

       Support functions

       constchar*libsmdev_get_version(void);

       intlibsmdev_get_access_flags_read(void);

       intlibsmdev_get_access_flags_read_write(void);

       intlibsmdev_get_access_flags_write(void);

       intlibsmdev_get_codepage(int*codepage, libsmdev_error_t**error);

       intlibsmdev_set_codepage(intcodepage, libsmdev_error_t**error);

       intlibsmdev_check_device(constchar*filename, libsmdev_error_t**error);

       Available when compiled with wide character string support:

       intlibsmdev_check_device_wide(constwchar_t*filename, libsmdev_error_t**error);

       Notify functions

       voidlibsmdev_notify_set_verbose(intverbose);

       intlibsmdev_notify_set_stream(FILE*stream, libsmdev_error_t**error);

       intlibsmdev_notify_stream_open(constchar*filename, libsmdev_error_t**error);

       intlibsmdev_notify_stream_close(libsmdev_error_t**error);

       Error functions

       voidlibsmdev_error_free(libsmdev_error_t**error);

       intlibsmdev_error_fprint(libsmdev_error_t*error, FILE*stream);

       intlibsmdev_error_sprint(libsmdev_error_t*error, char*string, size_tsize);

       intlibsmdev_error_backtrace_fprint(libsmdev_error_t*error, FILE*stream);

       intlibsmdev_error_backtrace_sprint(libsmdev_error_t*error, char*string, size_tsize);

       Handle functions

       intlibsmdev_handle_initialize(libsmdev_handle_t**handle, libsmdev_error_t**error);

       intlibsmdev_handle_free(libsmdev_handle_t**handle, libsmdev_error_t**error);

       intlibsmdev_handle_signal_abort(libsmdev_handle_t*handle, libsmdev_error_t**error);

       intlibsmdev_handle_open(libsmdev_handle_t*handle,    constchar*filename,    intaccess_flags,
           libsmdev_error_t**error);

       intlibsmdev_handle_close(libsmdev_handle_t*handle, libsmdev_error_t**error);

       ssize_tlibsmdev_handle_read_buffer(libsmdev_handle_t*handle,    uint8_t*buffer,    size_tbuffer_size,
           libsmdev_error_t**error);

       ssize_tlibsmdev_handle_read_buffer_at_offset(libsmdev_handle_t*handle,  uint8_t*buffer,  size_tbuffer_size,
           off64_toffset, libsmdev_error_t**error);

       ssize_tlibsmdev_handle_write_buffer(libsmdev_handle_t*handle,  constuint8_t*buffer,  size_tbuffer_size,
           libsmdev_error_t**error);

       ssize_tlibsmdev_handle_write_buffer_at_offset(libsmdev_handle_t*handle,     constuint8_t*buffer,
           size_tbuffer_size, off64_toffset, libsmdev_error_t**error);

       off64_tlibsmdev_handle_seek_offset(libsmdev_handle_t*handle,     off64_toffset,      intwhence,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_offset(libsmdev_handle_t*handle, off64_t*offset, libsmdev_error_t**error);

       intlibsmdev_handle_get_filename_size(libsmdev_handle_t*handle,        size_t*filename_size,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_filename(libsmdev_handle_t*handle,   char*filename,    size_tfilename_size,
           libsmdev_error_t**error);

       Available when compiled with wide character string support:

       intlibsmdev_handle_open_wide(libsmdev_handle_t*handle,   constwchar_t*filename,  intaccess_flags,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_filename_size_wide(libsmdev_handle_t*handle,       size_t*filename_size,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_filename_wide(libsmdev_handle_t*handle,  wchar_t*filename,  size_tfilename_size,
           libsmdev_error_t**error);

       Meta data functions

       intlibsmdev_handle_get_media_size(libsmdev_handle_t*handle,          size64_t*media_size,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_bytes_per_sector(libsmdev_handle_t*handle,      uint32_t*bytes_per_sector,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_media_type(libsmdev_handle_t*handle, uint8_t*media_type, libsmdev_error_t**error);

       intlibsmdev_handle_get_bus_type(libsmdev_handle_t*handle, uint8_t*bus_type, libsmdev_error_t**error);

       intlibsmdev_handle_get_utf8_information_value(libsmdev_handle_t*handle,   constuint8_t*identifier,
           size_tidentifier_length, uint8_t*utf8_string, size_tutf8_string_size, libsmdev_error_t**error);

       intlibsmdev_handle_get_utf16_information_value(libsmdev_handle_t*handle,   constuint8_t*identifier,
           size_tidentifier_length,      uint16_t*utf16_string,      size_tutf16_string_size,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_number_of_sessions(libsmdev_handle_t*handle,      int*number_of_sessions,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_session(libsmdev_handle_t*handle,    intindex,    uint64_t*start_sector,
           uint64_t*number_of_sectors, libsmdev_error_t**error);

       intlibsmdev_handle_get_number_of_tracks(libsmdev_handle_t*handle,       int*number_of_tracks,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_track(libsmdev_handle_t*handle,    intindex,     uint64_t*start_sector,
           uint64_t*number_of_sectors, uint8_t*type, libsmdev_error_t**error);

       intlibsmdev_handle_get_number_of_error_retries(libsmdev_handle_t*handle, uint8_t*number_of_error_retries,
           libsmdev_error_t**error);

       intlibsmdev_handle_set_number_of_error_retries(libsmdev_handle_t*handle,  uint8_tnumber_of_error_retries,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_error_granularity(libsmdev_handle_t*handle,      size_t*error_granularity,
           libsmdev_error_t**error);

       intlibsmdev_handle_set_error_granularity(libsmdev_handle_t*handle,      size_terror_granularity,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_error_flags(libsmdev_handle_t*handle,         uint8_t*error_flags,
           libsmdev_error_t**error);

       intlibsmdev_handle_set_error_flags(libsmdev_handle_t*handle,          uint8_terror_flags,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_number_of_errors(libsmdev_handle_t*handle,       int*number_of_errors,
           libsmdev_error_t**error);

       intlibsmdev_handle_get_error(libsmdev_handle_t*handle,  intindex,  off64_t*offset,   size64_t*size,
           libsmdev_error_t**error);