libwrc(3)

🌸 libwrc(3) 🌸

okay so this is the libwrc(3) entry from the Library Functions Manual (the (3) is just the manual section bestie, that's how the Library Functions girlies roll), and it is long, so it's split over two parts and you're holding part 1. grab a drink, stretch, we're going in 💅

---

✨ NAME ✨

libwrc.h — the library that gets you into the Windows Resource Compiler (WRC) format 🎀 that's the whole vibe, no cap.

---

🦋 SYNOPSIS 🦋

first move is always the same, include the header:

#include <libwrc.h>

and then it's giving groups. so many groups. here's every single one 💖

💖 Support functions 💖

the support crew — version string, access flags, and the codepage getter/setter pair:

const char *
libwrc_get_version(void);

int
libwrc_get_access_flags_read(void);

int
libwrc_get_codepage(int *codepage, libwrc_error_t **error);

int
libwrc_set_codepage(int codepage, libwrc_error_t **error);

🎀 Notify functions 🎀

the notify girlies — verbose toggle, set the stream, open one, close one. every single one takes the libwrc_error_t **error double pointer (yes, double, that's not a typo, that's just the pattern here 😭):

void
libwrc_notify_set_verbose(int verbose);

int
libwrc_notify_set_stream(FILE *stream, libwrc_error_t **error);

int
libwrc_notify_stream_open(const char *filename, libwrc_error_t **error);

int
libwrc_notify_stream_close(libwrc_error_t **error);

💀 Error functions 💀

error handling squad — there's a plain print and a backtrace print, and both come in fprint (stream) and sprint (string, with a size) flavours. keep the name, bestie, these two are so easy to mix up 🙈

void
libwrc_error_free(libwrc_error_t **error);

int
libwrc_error_fprint(libwrc_error_t *error, FILE *stream);

int
libwrc_error_sprint(libwrc_error_t *error, char *string, size_t size);

int
libwrc_error_backtrace_fprint(libwrc_error_t *error, FILE *stream);

int
libwrc_error_backtrace_sprint(libwrc_error_t *error, char *string,
    size_t size);

🌊 Stream functions 🌊

the big one. initialize it, free it, signal abort on it, open it, close it — and then a whole parade of codepage, virtual address, and resource-lookup functions ⭐

int
libwrc_stream_initialize(libwrc_stream_t **stream,
    libwrc_error_t **error);

int
libwrc_stream_free(libwrc_stream_t **stream, libwrc_error_t **error);

int
libwrc_stream_signal_abort(libwrc_stream_t *stream,
    libwrc_error_t **error);

int
libwrc_stream_open(libwrc_stream_t *stream, const char *filename,
    int access_flags, libwrc_error_t **error);

int
libwrc_stream_close(libwrc_stream_t *stream, libwrc_error_t **error);

int
libwrc_stream_get_ascii_codepage(libwrc_stream_t *stream,
    int *ascii_codepage, libwrc_error_t **error);

int
libwrc_stream_set_ascii_codepage(libwrc_stream_t *stream,
    int ascii_codepage, libwrc_error_t **error);

int
libwrc_stream_get_virtual_address(libwrc_stream_t *stream,
    uint32_t *virtual_address, libwrc_error_t **error);

int
libwrc_stream_set_virtual_address(libwrc_stream_t *stream,
    uint32_t virtual_address, libwrc_error_t **error);

int
libwrc_stream_get_number_of_resources(libwrc_stream_t *stream,
    int *number_of_resources, libwrc_error_t **error);

int
libwrc_stream_get_resource_by_index(libwrc_stream_t *stream,
    int resource_index, libwrc_resource_t **resource,
    libwrc_error_t **error);

int
libwrc_stream_get_resource_by_identifier(libwrc_stream_t *stream,
    uint32_t identifier, libwrc_resource_t **resource,
    libwrc_error_t **error);

int
libwrc_stream_get_resource_by_type(libwrc_stream_t *stream, int type,
    libwrc_resource_t **resource, libwrc_error_t **error);

int
libwrc_stream_get_resource_by_utf8_name(libwrc_stream_t *stream,
    const uint8_t *utf8_string, size_t utf8_string_length,
    libwrc_resource_t **resource, libwrc_error_t **error);

int
libwrc_stream_get_resource_by_utf16_name(libwrc_stream_t *stream,
    const uint16_t *utf16_string, size_t utf16_string_length,
    libwrc_resource_t **resource, libwrc_error_t **error);

🫶 heads up, the next one is available when compiled with wide character string support — so if your build didn't get that, she's simply not there:

int
libwrc_stream_open_wide(libwrc_stream_t *stream,
    const wchar_t *filename, int access_flags, libwrc_error_t **error);

🌟 and this one is available when compiled with libbfio support — same deal, build-dependent, and it takes a libbfio_handle_t *file_io_handle:

int
libwrc_stream_open_file_io_handle(libwrc_stream_t *stream,
    libbfio_handle_t *file_io_handle, int access_flags,
    libwrc_error_t **error);

🧚 Resource functions 🧚

free it, pull its identifier, grab its name as UTF-8 or UTF-16 (size first, buffer second — the classic two-step), get its type, count its items, then fetch an item by index:

int
libwrc_resource_free(libwrc_resource_t **resource,
    libwrc_error_t **error);

int
libwrc_resource_get_identifier(libwrc_resource_t *resource,
    uint32_t *identifier, libwrc_error_t **error);

int
libwrc_resource_get_utf8_name_size(libwrc_resource_t *resource,
    size_t *utf8_string_size, libwrc_error_t **error);

int
libwrc_resource_get_utf8_name(libwrc_resource_t *resource,
    uint8_t *utf8_string, size_t utf8_string_size,
    libwrc_error_t **error);

int
libwrc_resource_get_utf16_name_size(libwrc_resource_t *resource,
    size_t *utf16_string_size, libwrc_error_t **error);

int
libwrc_resource_get_utf16_name(libwrc_resource_t *resource,
    uint16_t *utf16_string, size_t utf16_string_size,
    libwrc_error_t **error);

int
libwrc_resource_get_type(libwrc_resource_t *resource, int *type,
    libwrc_error_t **error);

int
libwrc_resource_get_number_of_items(libwrc_resource_t *resource,
    int *number_of_items, libwrc_error_t **error);

int
libwrc_resource_get_item_by_index(libwrc_resource_t *resource,
    int item_index, libwrc_resource_item_t **resource_item,
    libwrc_error_t **error);

🍓 Resource item functions 🍓

the item-level girlies — identifier, UTF-8/UTF-16 names again, and then the actual content moves: read a buffer, seek an offset, ask for the offset, ask for the size, count the sub-items, and fetch a sub-item by index 🔥

int
libwrc_resource_item_free(libwrc_resource_item_t **resource_item,
    libwrc_error_t **error);

int
libwrc_resource_item_get_identifier(libwrc_resource_item_t *resource_item,
    uint32_t *identifier, libwrc_error_t **error);

int
libwrc_resource_item_get_utf8_name_size(libwrc_resource_item_t *resource_item,
    size_t *utf8_string_size, libwrc_error_t **error);

int
libwrc_resource_item_get_utf8_name(libwrc_resource_item_t *resource_item,
    uint8_t *utf8_string, size_t utf8_string_size,
    libwrc_error_t **error);

int
libwrc_resource_item_get_utf16_name_size(libwrc_resource_item_t *resource_item,
    size_t *utf16_string_size, libwrc_error_t **error);

int
libwrc_resource_item_get_utf16_name(libwrc_resource_item_t *resource_item,
    uint16_t *utf16_string, size_t utf16_string_size,
    libwrc_error_t **error);

ssize_t
libwrc_resource_item_read_buffer(libwrc_resource_item_t *resource_item,
    uint8_t *buffer, size_t size, libwrc_error_t **error);

off64_t
libwrc_resource_item_seek_offset(libwrc_resource_item_t *resource_item,
    off64_t offset, int whence, libwrc_error_t **error);

int
libwrc_resource_item_get_offset(libwrc_resource_item_t *resource_item,
    off64_t *offset, libwrc_error_t **error);

int
libwrc_resource_item_get_size(libwrc_resource_item_t *resource_item,
    uint32_t *size, libwrc_error_t **error);

int
libwrc_resource_item_get_number_of_sub_items(libwrc_resource_item_t *resource_item,
    int *number_of_sub_items, libwrc_error_t **error);

int
libwrc_resource_item_get_sub_item_by_index(libwrc_resource_item_t *resource_item,
    int sub_item_index, libwrc_resource_item_t **resource_sub_item,
    libwrc_error_t **error);

note the return types on those two: ssize_t for the buffer read and off64_t for the seek — not int like their friends 👑 (and yes libwrc_resource_item_seek_offset takes whence, exactly like you'd hope).

🌈 Manifest resource functions 🌈

manifest-specific crew — initialize, free, read a chunk of data with a data_size, then size-then-buffer for UTF-8, size-then-buffer for UTF-16:

int
libwrc_manifest_resource_initialize(libwrc_manifest_resource_t **manifest_resource,
    libwrc_error_t **error);

int
libwrc_manifest_resource_free(libwrc_manifest_resource_t **manifest_resource,
    libwrc_error_t **error);

int
libwrc_manifest_resource_read(libwrc_manifest_resource_t *manifest_resource,
    const uint8_t *data, size_t data_size, libwrc_error_t **error);

int
libwrc_manifest_resource_get_utf8_string_size(libwrc_manifest_resource_t *manifest_resource,
    size_t *utf8_string_size, libwrc_error_t **error);

int
libwrc_manifest_resource_get_utf8_string(libwrc_manifest_resource_t *manifest_resource,
    uint8_t *utf8_string, size_t utf8_string_size,
    libwrc_error_t **error);

int
libwrc_manifest_resource_get_utf16_string_size(libwrc_manifest_resource_t *manifest_resource,
    size_t *utf16_string_size, libwrc_error_t **error);

int
libwrc_manifest_resource_get_utf16_string(libwrc_manifest_resource_t *manifest_resource,
    uint16_t *utf16_string, size_t utf16_string_size,
    libwrc_error_t **error);

💜 Message table (MESSAGETABLE) resource functions 💜

the MESSAGETABLE set — initialize, free, and then read takes data, data_size and an ascii_codepage, so don't forget that third one bestie. after that it's counts, identifiers, index-by-identifier, and the usual UTF-8/UTF-16 size-then-string pairs (both of which take a message_index) ✨

int
libwrc_message_table_resource_initialize(libwrc_message_table_resource_t **message_table_resource,
    libwrc_error_t **error);

int
libwrc_message_table_resource_free(libwrc_message_table_resource_t **message_table_resource,
    libwrc_error_t **error);

int
libwrc_message_table_resource_read(libwrc_message_table_resource_t *message_table_resource,
    const uint8_t *data, size_t data_size, int ascii_codepage,
    libwrc_error_t **error);

int
libwrc_message_table_resource_get_number_of_messages(libwrc_message_table_resource_t *message_table_resource,
    int *number_of_messages, libwrc_error_t **error);

int
libwrc_message_table_resource_get_identifier(libwrc_message_table_resource_t *message_table_resource,
    int message_index, uint32_t *message_identifier,
    libwrc_error_t **error);

int
libwrc_message_table_resource_get_index_by_identifier(libwrc_message_table_resource_t *message_table_resource,
    uint32_t message_identifier, int *message_index,
    libwrc_error_t **error);

int
libwrc_message_table_resource_get_utf8_string_size(libwrc_message_table_resource_t *message_table_resource,
    int message_index, size_t *utf8_string_size,
    libwrc_error_t **error);

int
libwrc_message_table_resource_get_utf8_string(libwrc_message_table_resource_t *message_table_resource,
    int message_index, uint8_t *utf8_string, size_t utf8_string_size,
    libwrc_error_t **error);

int
libwrc_message_table_resource_get_utf16_string_size(libwrc_message_table_resource_t *message_table_resource,
    int message_index, size_t *utf16_string_size,
    libwrc_error_t **error);

int
libwrc_message_table_resource_get_utf16_string(libwrc_message_table_resource_t *message_table_resource,
    int message_index, uint16_t *utf16_string, size_t utf16_string_size,
    libwrc_error_t **error);

🦋 MUI resource functions 🦋

last group of the synopsis and it's the MUI one — initialize, free, read, then file_type plus the main-name pulls in UTF-8 and UTF-16 (size first, then the string, you know the drill by now) 🎀

int
libwrc_mui_resource_initialize(libwrc_mui_resource_t **mui_resource,
    libwrc_error_t **error);

int
libwrc_mui_resource_free(libwrc_mui_resource_t **mui_resource,
    libwrc_error_t **error);

int
libwrc_mui_resource_read(libwrc_mui_resource_t *mui_resource,
    const uint8_t *data, size_t data_size, libwrc_error_t **error);

int
libwrc_mui_resource_get_file_type(libwrc_mui_resource_t *mui_resource,
    uint32_t *file_type, libwrc_error_t **error);

int
libwrc_mui_resource_get_utf8_main_name_size(libwrc_mui_resource_t *mui_resource,
    size_t *utf8_string_size, libwrc_error_t **error);

int
libwrc_mui_resource_get_utf8_main_name(libwrc_mui_resource_t *mui_resource,
    uint8_t *utf8_string, size_t utf8_string_size,
    libwrc_error_t **error);

int
libwrc_mui_resource_get_utf16_main_name_size(libwrc_mui_resource_t *mui_resource,
    size_t *utf16_string_size, libwrc_error_t **error);

int
libwrc_mui_resource_get_utf16_main_name(libwrc_mui_resource_t *mui_resource,
    uint16_t *utf16_string, size_t utf16_string_size,
    libwrc_error_t **error);

and that's where part 1 stops — there's more page, keep it moving 👀

here's the rest of the function lineup, bestie — every signature exactly as it lives in the header 👑

       int
       libwrc_mui_resource_get_utf8_mui_name_size(libwrc_mui_resource_t *mui_resource,
           size_t *utf8_string_size, libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf8_mui_name(libwrc_mui_resource_t *mui_resource,
           uint8_t *utf8_string, size_t utf8_string_size,
           libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf16_mui_name_size(libwrc_mui_resource_t *mui_resource,
           size_t *utf16_string_size, libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf16_mui_name(libwrc_mui_resource_t *mui_resource,
           uint16_t *utf16_string, size_t utf16_string_size,
           libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf8_language_size(libwrc_mui_resource_t *mui_resource,
           size_t *utf8_string_size, libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf8_language(libwrc_mui_resource_t *mui_resource,
           uint8_t *utf8_string, size_t utf8_string_size,
           libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf16_language_size(libwrc_mui_resource_t *mui_resource,
           size_t *utf16_string_size, libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf16_language(libwrc_mui_resource_t *mui_resource,
           uint16_t *utf16_string, size_t utf16_string_size,
           libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf8_fallback_language_size(libwrc_mui_resource_t *mui_resource,
           size_t *utf8_string_size, libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf8_fallback_language(libwrc_mui_resource_t *mui_resource,
           uint8_t *utf8_string, size_t utf8_string_size,
           libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf16_fallback_language_size(libwrc_mui_resource_t *mui_resource,
           size_t *utf16_string_size, libwrc_error_t **error);

       int
       libwrc_mui_resource_get_utf16_fallback_language(libwrc_mui_resource_t *mui_resource,
           uint16_t *utf16_string, size_t utf16_string_size,
           libwrc_error_t **error);

🎀 String table (STRINGTABLE) resource functions 🎀

       int
       libwrc_string_table_resource_initialize(libwrc_string_table_resource_t **string_table_resource,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_free(libwrc_string_table_resource_t **string_table_resource,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_read(libwrc_string_table_resource_t *string_table_resource,
           const uint8_t *data, size_t data_size, uint32_t base_identifier,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_number_of_strings(libwrc_string_table_resource_t *string_table_resource,
           int *number_of_strings, libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_identifier(libwrc_string_table_resource_t *string_table_resource,
           int string_index, uint32_t *string_identifier,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_index_by_identifier(libwrc_string_table_resource_t *string_table_resource,
           uint32_t string_identifier, int *string_index,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_utf8_string_size(libwrc_string_table_resource_t *string_table_resource,
           int string_index, size_t *utf8_string_size, libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_utf8_string(libwrc_string_table_resource_t *string_table_resource,
           int string_index, uint8_t *utf8_string, size_t utf8_string_size,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_utf16_string_size(libwrc_string_table_resource_t *string_table_resource,
           int string_index, size_t *utf16_string_size,
           libwrc_error_t **error);

       int
       libwrc_string_table_resource_get_utf16_string(libwrc_string_table_resource_t *string_table_resource,
           int string_index, uint16_t *utf16_string, size_t utf16_string_size,
           libwrc_error_t **error);

🎀 Version information (VERSIONINFO) resource functions 🎀

       int
       libwrc_version_information_resource_initialize(libwrc_version_information_resource_t **version_information_resource,
           libwrc_error_t **error);

       int
       libwrc_version_information_resource_free(libwrc_version_information_resource_t **version_information_resource,
           libwrc_error_t **error);

       int
       libwrc_version_information_resource_read(libwrc_version_information_resource_t *version_information_resource,
           const uint8_t *data, size_t data_size, libwrc_error_t **error);

       int
       libwrc_version_information_resource_get_file_version(libwrc_version_information_resource_t *version_information_resource,
           uint64_t *file_version, libwrc_error_t **error);

       int
       libwrc_version_information_resource_get_product_version(libwrc_version_information_resource_t *version_information_resource,
           uint64_t *product_version, libwrc_error_t **error);

---

💖 DESCRIPTION 💖

okay so the one function with its own little sentence here is libwrc_get_version() — it's used to retrieve the library version. that's the whole description, bestie, and it ate 💅

---

✨ RETURN VALUES ✨

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

so like, if you need the exact tea on what comes back, the header is right there 👀

---

🌸 ENVIRONMENT 🌸

None

literally no environment variables to worry about, bestie 😌

---

🦋 FILES 🦋

None

no files, no paths, nothing to chase 🫶

---

🎀 NOTES 🎀

libwrc can be compiled with wide character support (wchar_t). iconic.

To compile libwrc with wide character support use:

./configure --enable-wide-character-type=yes

or define:

_UNICODE

or

UNICODE

during compilation.

LIBWRC_WIDE_CHARACTER_TYPE in libwrc/features.h can be used to determine if libwrc was compiled with wide character support. yes bestie, there's a little flag in the header for the vibe check 🧚

---

💀 BUGS 💀

Please report bugs of any kind on the project issue tracker:

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

don't be shy, they want the tea 🐛💖

---

👑 AUTHOR 👑

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

generated, not hand-typed by a mysterious wizard — slay 🧚

---

💜 COPYRIGHT 💜

Copyright (C) 2011-2024, 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 libwrc.h include file

that's the whole see-also, bestie — go peek at the header 👀

---

💖 and that's the whole page — from libwrc, dated January 3, 2022. mwah 💅✨