libfdata(3)

📦 in opensuse-leap 16.0

💖 libfdata(3) — Library Functions Manual 💖

okay so bestie, this is libfdata(3), the manual page for libfdata.h, and it is a lot — like, a whole library's worth of function signatures. grab a snack 🍓, we're going through every single one, no skipping, no summarising, periodt.

🎀 NAME 🎀

libfdata.h — the library that provides generic file data functions ✨ that's the whole vibe, that's what it does.

🌸 SYNOPSIS 🌸

first things first, you gotta pull it in:

#include <libfdata.h>

and then... yeah. everything. literally everything. here we go 👑

🫶 Support functions

const char *
libfdata_get_version(void);

🔔 Notify functions

void
libfdata_notify_set_verbose(int verbose);

int
libfdata_notify_set_stream(FILE *stream, libfdata_error_t **error);

int
libfdata_notify_stream_open(const char *filename,
    libfdata_error_t **error);

int
libfdata_notify_stream_close(libfdata_error_t **error);

💀 Error functions

void
libfdata_error_free(libfdata_error_t **error);

int
libfdata_error_fprint(libfdata_error_t *error, FILE *stream);

int
libfdata_error_sprint(libfdata_error_t *error, char *string,
    size_t size);

int
libfdata_error_backtrace_fprint(libfdata_error_t *error, FILE *stream);

int
libfdata_error_backtrace_sprint(libfdata_error_t *error, char *string,
    size_t size);

🦋 Cache functions

int
libfdata_cache_initialize(libfdata_cache_t **cache,
    int maximum_cache_entries, libfdata_error_t **error);

int
libfdata_cache_free(libfdata_cache_t **cache, libfdata_error_t **error);

🌈 Area functions

okay this one is the big one, the main character of the synopsis. look at all those function pointers. she's iconic but she's also lowkey a lot 💅

int
libfdata_area_initialize(libfdata_area_t **area,
    size64_t element_data_size, intptr_t *data_handle,
    int (*free_data_handle)( intptr_t **data_handle, libfdata_error_t **error ),
    int (*clone_data_handle)( intptr_t **destination_data_handle, intptr_t *source_data_handle, libfdata_error_t **error ),
    int (*read_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_area_t *area, libfdata_cache_t *cache, off64_t element_value_offset, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t read_flags, libfdata_error_t **error ),
    int (*write_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_area_t *area, libfdata_cache_t *cache, off64_t element_value_offset, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t write_flags, libfdata_error_t **error ),
    uint8_t flags, libfdata_error_t **error);

and the rest of the area girlies:

int
libfdata_area_free(libfdata_area_t **area, libfdata_error_t **error);

int
libfdata_area_clone(libfdata_area_t **destination_area,
    libfdata_area_t *source_area, libfdata_error_t **error);

int
libfdata_area_empty(libfdata_area_t *area, libfdata_error_t **error);

int
libfdata_area_resize(libfdata_area_t *area, int number_of_segments,
    libfdata_error_t **error);

int
libfdata_area_get_number_of_segments(libfdata_area_t *area,
    int *number_of_segments, libfdata_error_t **error);

int
libfdata_area_get_segment_by_index(libfdata_area_t *area,
    int segment_index, int *segment_file_index, off64_t *segment_offset,
    size64_t *segment_size, uint32_t *segment_flags,
    libfdata_error_t **error);

int
libfdata_area_set_segment_by_index(libfdata_area_t *area,
    int segment_index, int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_area_prepend_segment(libfdata_area_t *area,
    int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_area_append_segment(libfdata_area_t *area, int *segment_index,
    int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_area_get_element_data_size(libfdata_area_t *area,
    size64_t *element_data_size, libfdata_error_t **error);

int
libfdata_area_get_element_value_at_offset(libfdata_area_t *area,
    intptr_t *file_io_handle, libfdata_cache_t *cache,
    off64_t element_value_offset, intptr_t **element_value,
    uint8_t read_flags, libfdata_error_t **error);

int
libfdata_area_set_element_value_at_offset(libfdata_area_t *area,
    intptr_t *file_io_handle, libfdata_cache_t *cache,
    off64_t element_value_offset, intptr_t *element_value,
    int (*free_element_value)( intptr_t **element_value, libfdata_error_t **error ),
    uint8_t write_flags, libfdata_error_t **error);

int
libfdata_area_get_size(libfdata_area_t *area, size64_t *size,
    libfdata_error_t **error);

⭐ List functions

and now the list functions, aka the longest section, aka the one that ate and left no crumbs 🍽️

int
libfdata_list_initialize(libfdata_list_t **list, intptr_t *data_handle,
    int (*free_data_handle)( intptr_t **data_handle, libfdata_error_t **error ),
    int (*clone_data_handle)( intptr_t **destination_data_handle, intptr_t *source_data_handle, libfdata_error_t **error ),
    int (*read_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_list_element_t *list_element, libfdata_cache_t *cache, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t read_flags, libfdata_error_t **error ),
    int (*write_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_list_element_t *list_element, libfdata_cache_t *cache, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t write_flags, libfdata_error_t **error ),
    uint8_t flags, libfdata_error_t **error);

int
libfdata_list_free(libfdata_list_t **list, libfdata_error_t **error);

int
libfdata_list_clone(libfdata_list_t **destination_list,
    libfdata_list_t *source_list, libfdata_error_t **error);

int
libfdata_list_empty(libfdata_list_t *list, libfdata_error_t **error);

int
libfdata_list_resize(libfdata_list_t *list, int number_of_elements,
    libfdata_error_t **error);

int
libfdata_list_reverse(libfdata_list_t *list, libfdata_error_t **error);

int
libfdata_list_get_number_of_elements(libfdata_list_t *list,
    int *number_of_elements, libfdata_error_t **error);

int
libfdata_list_get_list_element_by_index(libfdata_list_t *list,
    int element_index, libfdata_list_element_t **element,
    libfdata_error_t **error);

int
libfdata_list_get_element_by_index(libfdata_list_t *list,
    int element_index, int *element_file_index, off64_t *element_offset,
    size64_t *element_size, uint32_t *element_flags,
    libfdata_error_t **error);

int
libfdata_list_set_element_by_index(libfdata_list_t *list,
    int element_index, int element_file_index, off64_t element_offset,
    size64_t element_size, uint32_t element_flags,
    libfdata_error_t **error);

int
libfdata_list_prepend_element(libfdata_list_t *list,
    int element_file_index, off64_t element_offset,
    size64_t element_size, uint32_t element_flags,
    libfdata_error_t **error);

int
libfdata_list_append_element(libfdata_list_t *list, int *element_index,
    int element_file_index, off64_t element_offset,
    size64_t element_size, uint32_t element_flags,
    libfdata_error_t **error);

int
libfdata_list_append_list(libfdata_list_t *list,
    libfdata_list_t *source_list, libfdata_error_t **error);

int
libfdata_list_is_element_set(libfdata_list_t *list, int element_index,
    libfdata_error_t **error);

int
libfdata_list_get_element_mapped_range(libfdata_list_t *list,
    int element_index, off64_t *mapped_range_offset,
    size64_t *mapped_range_size, libfdata_error_t **error);

int
libfdata_list_get_mapped_offset(libfdata_list_t *list,
    off64_t *mapped_offset, libfdata_error_t **error);

int
libfdata_list_set_mapped_offset(libfdata_list_t *list,
    off64_t mapped_offset, libfdata_error_t **error);

int
libfdata_list_get_mapped_size_by_index(libfdata_list_t *list,
    int element_index, size64_t *mapped_size, libfdata_error_t **error);

int
libfdata_list_set_mapped_size_by_index(libfdata_list_t *list,
    int element_index, size64_t mapped_size, libfdata_error_t **error);

int
libfdata_list_get_element_by_index_with_mapped_size(libfdata_list_t *list,
    int element_index, int *element_file_index, off64_t *element_offset,
    size64_t *element_size, uint32_t *element_flags,
    size64_t *mapped_size, libfdata_error_t **error);

int
libfdata_list_set_element_by_index_with_mapped_size(libfdata_list_t *list,
    int element_index, int element_file_index, off64_t element_offset,
    size64_t element_size, uint32_t element_flags, size64_t mapped_size,
    libfdata_error_t **error);

int
libfdata_list_append_element_with_mapped_size(libfdata_list_t *list,
    int *element_index, int element_file_index, off64_t element_offset,
    size64_t element_size, uint32_t element_flags, size64_t mapped_size,
    libfdata_error_t **error);

int
libfdata_list_get_element_index_at_offset(libfdata_list_t *list,
    off64_t offset, int *element_index, off64_t *element_data_offset,
    libfdata_error_t **error);

int
libfdata_list_get_list_element_at_offset(libfdata_list_t *list,
    off64_t offset, int *element_index, off64_t *element_data_offset,
    libfdata_list_element_t **element, libfdata_error_t **error);

int
libfdata_list_get_element_at_offset(libfdata_list_t *list,
    off64_t offset, int *element_index, off64_t *element_data_offset,
    int *element_file_index, off64_t *element_offset,
    size64_t *element_size, uint32_t *element_flags,
    libfdata_error_t **error);

int
libfdata_list_get_element_value_by_index(libfdata_list_t *list,
    intptr_t *file_io_handle, libfdata_cache_t *cache,
    int element_index, intptr_t **element_value, uint8_t read_flags,
    libfdata_error_t **error);

int
libfdata_list_get_element_value_at_offset(libfdata_list_t *list,
    intptr_t *file_io_handle, libfdata_cache_t *cache, off64_t offset,
    int *element_index, off64_t *element_data_offset,
    intptr_t **element_value, uint8_t read_flags,
    libfdata_error_t **error);

int
libfdata_list_set_element_value_by_index(libfdata_list_t *list,
    intptr_t *file_io_handle, libfdata_cache_t *cache,
    int element_index, intptr_t *element_value,
    int (*free_element_value)( intptr_t **element_value, libfdata_error_t **error ),
    uint8_t write_flags, libfdata_error_t **error);

int
libfdata_list_set_element_value_at_offset(libfdata_list_t *list,
    intptr_t *file_io_handle, libfdata_cache_t *cache, off64_t offset,
    intptr_t *element_value,
    int (*free_element_value)( intptr_t **element_value, libfdata_error_t **error ),
    uint8_t write_flags, libfdata_error_t **error);

int
libfdata_list_get_size(libfdata_list_t *list, size64_t *size,
    libfdata_error_t **error);

🧚 List element functions

and that's where this part of the page dips, bestie — the list element functions are right there and we're literally not done yet, so don't go anywhere 💜 (more parts incoming fr fr)

int
libfdata_list_element_get_element_index(libfdata_list_element_t *element,
    int *element_index, libfdata_error_t **error);

int
libfdata_list_element_get_data_range(libfdata_list_element_t *element,
    int *file_index, off64_t *offset, size64_t *size, uint32_t *flags,
    libfdata_error_t **error);

int
libfdata_list_element_get_mapped_size(libfdata_list_element_t *element,
    size64_t *mapped_size, libfdata_error_t **error);

int
libfdata_list_element_set_mapped_size(libfdata_list_element_t *element,
    size64_t mapped_size, libfdata_error_t **error);

int
libfdata_list_element_get_element_value(libfdata_list_element_t *element,
    intptr_t *file_io_handle, libfdata_cache_t *cache,
    intptr_t **element_value, uint8_t read_flags,
    libfdata_error_t **error);

int
libfdata_list_element_set_element_value(libfdata_list_element_t *element,
    intptr_t *file_io_handle, libfdata_cache_t *cache,
    intptr_t *element_value,
    int (*free_element_value)( intptr_t **element_value, libfdata_error_t **error ),
    uint8_t write_flags, libfdata_error_t **error);

okay so those are the list-element accessors 💅 and yes, there's a whole get/set situation going on — get_element_index, get_data_range, get_mapped_size/set_mapped_size, and then the big ones get_element_value / set_element_value that take a file_io_handle, a cache, and read_flags/write_flags. The setter even wants a free_element_value callback, because someone has to clean up after the party 🎉. No cap, just read the signatures.

🎀 Range list functions 🎀

✨ These are the range-list girlies — they need a data_handle and a whole squad of callbacks: free_data_handle, clone_data_handle, read_element_data, write_element_data, plus flags. Sit down, this is a long one 💖

int
libfdata_range_list_initialize(libfdata_range_list_t **range_list,
    intptr_t *data_handle,
    int (*free_data_handle)( intptr_t **data_handle, libfdata_error_t **error ),
    int (*clone_data_handle)( intptr_t **destination_data_handle, intptr_t *source_data_handle, libfdata_error_t **error ),
    int (*read_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_list_element_t *list_element, libfdata_cache_t *cache, int element_file_index, off64_t element_offset, size64_t element_size, uint32_t element_flags, uint8_t read_flags, libfdata_error_t **error ),
    int (*write_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_list_element_t *list_element, libfdata_cache_t *cache, int element_file_index, off64_t element_offset, size64_t element_size, uint32_t element_flags, uint8_t write_flags, libfdata_error_t **error ),
    uint8_t flags, libfdata_error_t **error);

int
libfdata_range_list_free(libfdata_range_list_t **range_list,
    libfdata_error_t **error);

int
libfdata_range_list_clone(libfdata_range_list_t **destination_range_list,
    libfdata_range_list_t *source_range_list, libfdata_error_t **error);

int
libfdata_range_list_empty(libfdata_range_list_t *range_list,
    libfdata_error_t **error);

int
libfdata_range_list_get_list_element_at_offset(libfdata_range_list_t *range_list,
    off64_t offset, off64_t *element_data_offset,
    libfdata_list_element_t **element, libfdata_error_t **error);

int
libfdata_range_list_get_element_at_offset(libfdata_range_list_t *range_list,
    off64_t offset, off64_t *element_data_offset,
    int *element_file_index, off64_t *element_offset,
    size64_t *element_size, uint32_t *element_flags,
    libfdata_error_t **error);

int
libfdata_range_list_insert_element(libfdata_range_list_t *range_list,
    off64_t offset, size64_t size, int element_file_index,
    off64_t element_offset, size64_t element_size,
    uint32_t element_flags, libfdata_error_t **error);

int
libfdata_range_list_get_element_value_at_offset(libfdata_range_list_t *range_list,
    intptr_t *file_io_handle, libfdata_cache_t *cache, off64_t offset,
    off64_t *element_data_offset, intptr_t **element_value,
    uint8_t read_flags, libfdata_error_t **error);

int
libfdata_range_list_set_element_value_at_offset(libfdata_range_list_t *range_list,
    intptr_t *file_io_handle, libfdata_cache_t *cache, off64_t offset,
    intptr_t *element_value,
    int (*free_element_value)( intptr_t **element_value, libfdata_error_t **error ),
    uint8_t write_flags, libfdata_error_t **error);

so basically: initialize builds it 🛠️, free yeets it 🗑️, clone makes a twin (twinning fr fr 👯), empty checks if there's literally nothing there, and then everything else is offset-based — get_list_element_at_offset, get_element_at_offset, insert_element, get_element_value_at_offset, set_element_value_at_offset. It's giving "everything is an offset and I'm obsessed" 🎯. The insert_element one wants offset, size, element_file_index, element_offset, element_size, element_flags — six things, she's high maintenance and that's iconic 💅.

🌊 Stream functions 🌊

stream queen behavior 🌊✨ libfdata_stream_initialize comes with the full callback roster: free_data_handle, clone_data_handle, create_segment, read_segment_data, write_segment_data, seek_segment_offset, flags. That's a lot of function pointers bestie — copy them exactly, they are load-bearing 🫶

int
libfdata_stream_initialize(libfdata_stream_t **stream,
    intptr_t *data_handle,
    int (*free_data_handle)( intptr_t **data_handle, libfdata_error_t **error ),
    int (*clone_data_handle)( intptr_t **destination_data_handle, intptr_t *source_data_handle, libfdata_error_t **error ),
    int (*create_segment)( intptr_t *data_handle, intptr_t *file_io_handle, int segment_index, int *segment_file_index, off64_t *segment_offset, size64_t *segment_size, uint32_t *segment_flags, libfdata_error_t **error ),
    ssize_t (*read_segment_data)( intptr_t *data_handle, intptr_t *file_io_handle, int segment_index, int segment_file_index, uint8_t *segment_data, size_t segment_data_size, uint32_t segment_flags, uint8_t read_flags, libfdata_error_t **error ),
    ssize_t (*write_segment_data)( intptr_t *data_handle, intptr_t *file_io_handle, int segment_index, int segment_file_index, const uint8_t *segment_data, size_t segment_data_size, uint32_t segment_flags, uint8_t write_flags, libfdata_error_t **error ),
    off64_t (*seek_segment_offset)( intptr_t *data_handle, intptr_t *file_io_handle, int segment_index, int segment_file_index, off64_t segment_offset, libfdata_error_t **error ),
    uint8_t flags, libfdata_error_t **error);

int
libfdata_stream_free(libfdata_stream_t **stream,
    libfdata_error_t **error);

int
libfdata_stream_clone(libfdata_stream_t **destination_stream,
    libfdata_stream_t *source_stream, libfdata_error_t **error);

int
libfdata_stream_empty(libfdata_stream_t *stream,
    libfdata_error_t **error);

int
libfdata_stream_resize(libfdata_stream_t *stream,
    int number_of_segments, libfdata_error_t **error);

int
libfdata_stream_reverse(libfdata_stream_t *stream,
    libfdata_error_t **error);

int
libfdata_stream_get_number_of_segments(libfdata_stream_t *stream,
    int *number_of_segments, libfdata_error_t **error);

int
libfdata_stream_get_segment_by_index(libfdata_stream_t *stream,
    int segment_index, int *segment_file_index, off64_t *segment_offset,
    size64_t *segment_size, uint32_t *segment_flags,
    libfdata_error_t **error);

int
libfdata_stream_set_segment_by_index(libfdata_stream_t *stream,
    int segment_index, int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_stream_prepend_segment(libfdata_stream_t *stream,
    int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_stream_append_segment(libfdata_stream_t *stream,
    int *segment_index, int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_stream_set_mapped_size(libfdata_stream_t *stream,
    size64_t mapped_size, libfdata_error_t **error);

int
libfdata_stream_get_segment_mapped_range(libfdata_stream_t *stream,
    int segment_index, off64_t *mapped_range_offset,
    size64_t *mapped_range_size, libfdata_error_t **error);

int
libfdata_stream_get_segment_index_at_offset(libfdata_stream_t *stream,
    off64_t data_offset, int *segment_index,
    off64_t *segment_data_offset, libfdata_error_t **error);

int
libfdata_stream_get_segment_at_offset(libfdata_stream_t *stream,
    off64_t offset, int *segment_index, off64_t *segment_data_offset,
    int *segment_file_index, off64_t *segment_offset,
    size64_t *segment_size, uint32_t *segment_flags,
    libfdata_error_t **error);

and the actual I/O girlies 🫶 these are the ones you're really here for:

ssize_t
libfdata_stream_read_buffer(libfdata_stream_t *stream,
    intptr_t *file_io_handle, uint8_t *buffer, size_t buffer_size,
    uint8_t read_flags, libfdata_error_t **error);

ssize_t
libfdata_stream_read_buffer_at_offset(libfdata_stream_t *stream,
    intptr_t *file_io_handle, uint8_t *buffer, size_t buffer_size,
    off64_t offset, uint8_t read_flags, libfdata_error_t **error);

ssize_t
libfdata_stream_write_buffer(libfdata_stream_t *stream,
    intptr_t *file_io_handle, const uint8_t *buffer, size_t buffer_size,
    uint8_t write_flags, libfdata_error_t **error);

off64_t
libfdata_stream_seek_offset(libfdata_stream_t *stream, off64_t offset,
    int whence, libfdata_error_t **error);

int
libfdata_stream_get_offset(libfdata_stream_t *stream, off64_t *offset,
    libfdata_error_t **error);

int
libfdata_stream_get_size(libfdata_stream_t *stream, size64_t *size,
    libfdata_error_t **error);

okay so the stream has: resize (with number_of_segments), reverse (yes it genuinely just flips it 🔄), segment getters/setters by segment_index, prepend_segment vs append_segment (note append_segment gives you back a *segment_index but prepend_segment does not — the way I clocked that 👀), set_mapped_size, get_segment_mapped_range, get_segment_index_at_offset, get_segment_at_offset, and then the read/write/seek trio plus get_offset and get_size. read_buffer and write_buffer return ssize_t and seek_offset returns off64_t — don't mix those up bestie 😭. Also write_buffer takes a const uint8_t *buffer while read_buffer takes plain uint8_t *buffer, and yes that distinction ate 💅.

🧊 Vector functions 🧊

last but never least, the vector section 🦋 libfdata_vector_initialize takes element_data_size up front (main character detail ✨) and the read_element_data / write_element_data callbacks are the vector flavor — they get a libfdata_vector_t *vector, an element_index, element_data_file_index, element_data_offset, element_data_size, and element_data_flags. Different signatures from the list and stream ones, so do not swap them, I'm begging 🙈

int
libfdata_vector_initialize(libfdata_vector_t **vector,
    size64_t element_data_size, intptr_t *data_handle,
    int (*free_data_handle)( intptr_t **data_handle, libfdata_error_t **error ),
    int (*clone_data_handle)( intptr_t **destination_data_handle, intptr_t *source_data_handle, libfdata_error_t **error ),
    int (*read_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_vector_t *vector, libfdata_cache_t *cache, int element_index, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t read_flags, libfdata_error_t **error ),
    int (*write_element_data)( intptr_t *data_handle, intptr_t *file_io_handle, libfdata_vector_t *vector, libfdata_cache_t *cache, int element_index, int element_data_file_index, off64_t element_data_offset, size64_t element_data_size, uint32_t element_data_flags, uint8_t write_flags, libfdata_error_t **error ),
    uint8_t flags, libfdata_error_t **error);

int
libfdata_vector_free(libfdata_vector_t **vector,
    libfdata_error_t **error);

int
libfdata_vector_clone(libfdata_vector_t **destination_vector,
    libfdata_vector_t *source_vector, libfdata_error_t **error);

int
libfdata_vector_empty(libfdata_vector_t *vector,
    libfdata_error_t **error);

int
libfdata_vector_resize(libfdata_vector_t *vector,
    int number_of_segments, libfdata_error_t **error);

int
libfdata_vector_get_number_of_segments(libfdata_vector_t *vector,
    int *number_of_segments, libfdata_error_t **error);

int
libfdata_vector_get_segment_by_index(libfdata_vector_t *vector,
    int segment_index, int *segment_file_index, off64_t *segment_offset,
    size64_t *segment_size, uint32_t *segment_flags,
    libfdata_error_t **error);

int
libfdata_vector_set_segment_by_index(libfdata_vector_t *vector,
    int segment_index, int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_vector_prepend_segment(libfdata_vector_t *vector,
    int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

int
libfdata_vector_append_segment(libfdata_vector_t *vector,
    int *segment_index, int segment_file_index, off64_t segment_offset,
    size64_t segment_size, uint32_t segment_flags,
    libfdata_error_t **error);

so the vector has free, clone, empty, resize (again with number_of_segments), get_number_of_segments, get_segment_by_index/set_segment_by_index, prepend_segment, append_segment — and yeah, same pattern as before: the append one hands you a *segment_index and the prepend one doesn't 🎀. That's the vibe check on the whole synopsis, fr fr ⭐

       int
       libfdata_vector_get_element_data_size(libfdata_vector_t *vector,
           size64_t *element_data_size, libfdata_error_t **error);

       int
       libfdata_vector_get_number_of_elements(libfdata_vector_t *vector,
           int *number_of_elements, libfdata_error_t **error);

       int
       libfdata_vector_get_element_index_at_offset(libfdata_vector_t *vector,
           off64_t element_value_offset, int *element_index,
           off64_t *element_data_offset, libfdata_error_t **error);

       int
       libfdata_vector_get_element_value_by_index(libfdata_vector_t *vector,
           intptr_t *file_io_handle, libfdata_cache_t *cache,
           int element_index, intptr_t **element_value, uint8_t read_flags,
           libfdata_error_t **error);

       int
       libfdata_vector_get_element_value_at_offset(libfdata_vector_t *vector,
           intptr_t *file_io_handle, libfdata_cache_t *cache,
           off64_t element_value_offset, off64_t *element_data_offset,
           intptr_t **element_value, uint8_t read_flags,
           libfdata_error_t **error);

       int
       libfdata_vector_set_element_value_by_index(libfdata_vector_t *vector,
           intptr_t *file_io_handle, libfdata_cache_t *cache,
           int element_index, intptr_t *element_value,
           int (*free_element_value)( intptr_t **element_value, libfdata_error_t **error ),
           uint8_t write_flags, libfdata_error_t **error);

       int
       libfdata_vector_get_size(libfdata_vector_t *vector, size64_t *size,
           libfdata_error_t **error);

okay so that's the rest of the prototype parade — yes, there really are that many, and yes, they're all right there in the synopsis, bestie. no gatekeeping here 💅

🦋 DESCRIPTION 🦋

okay so listen — the libfdata_get_version() function is the one that's like. the little version-checking fairy of this whole situation 🧚 it's used to retrieve the library version. that's it, that's the whole job, and it does it flawlessly. iconic behavior, honestly ✨

🌸 RETURN VALUES 🌸

most of the functions are gonna hit you with NULL or -1 when something goes wrong — which one you get depends entirely on their return type, so don't come for them about it 😭

for the actual, specific, no-vibes-only return values, go check "libfdata.h" — that's where the receipts live 🧾

✨ ENVIRONMENT ✨

None. literally nothing. no environment variables to memorize, no late-night "wait which var did I need to export" panic. we love a low-maintenance icon 🫶

🎀 FILES 🎀

None. same energy. nothing here either. slay 💅

💀 BUGS 💀

found a bug? bestie, please report bugs of any kind on the project issue tracker, we genuinely want to know 👑

https://github.com/libyal/libfdata/issues

no cap, any kind. don't be shy about it 🙈

👑 AUTHOR 👑

these man pages are generated from "libfdata.h". that's the whole lore ✨

Copyright (C) 2010-2024, Joachim Metz <joachim.metz@gmail.com>.

this is free software; see the source for copying conditions. and fr fr, there is NO warranty — not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. like, zero. none. don't @ me 😭

⭐ SEE ALSO ⭐

  • the libfdata.h include file — the main character of this entire page, honestly 🫶

okay that's the whole thing, you made it to the end!! 🎉 this was libfdata, section 3, dated March 20, 2023 — go forth and vector your data, bestie 💖🦋✨

📦 where this page comes from