R_UTIL(3)

💖 NAME 💖

Okay so bestie, meet r_util — the radare2 utility library — and this is its section 3 library-functions manual page. It’s literally the utility drawer of radare2: number parsing, strings, buffers, memory stuff, file stuff, and a whole bunch of data structures. Slay.

✨ SYNOPSIS ✨

#include <r_util.h>

🦋 DESCRIPTION 🦋

The r_util library is a comprehensive collection of utility functions for radare2, including number parsing, string manipulation, buffer management, memory operations, file handling, and various data structures. It’s lowkey the foundation for many other radare2 libraries — main character energy, fr fr.

🔢 NUMBERS 🔢

Parse and format numeric values, convert textual representations into integers, recognize human-friendly unit suffixes, and evaluate simple mathematical expressions. It’s giving handy for configuration parsing, user input handling, and preparing numbers for display. Obsessed.

• RNum * r_num_new(RNumCallback cb, RNumCallback2 cb2, void *ptr) — creates a new number parsing context with custom callbacks.
• ut64 r_num_get(RNum *num, const char *str) — parses a string into a 64-bit unsigned integer, supporting various formats.
• ut64 r_num_math(RNum *num, const char *str) — evaluates mathematical expressions in strings.
• char * r_num_units(char *buf, size_t len, ut64 number) — formats a number with appropriate units (KB, MB, etc.).

🧺 BUFFERS 🧺

Create and manipulate in-memory buffers that support reading, writing, seeking, and size queries — handy for temporary storage, streaming data between components, or abstracting underlying storage. The versatility is iconic.

• RBuffer * r_buf_new(void) — creates a new buffer.
• st64 r_buf_read(RBuffer *b, ut8 *buf, ut64 len) — reads data from a buffer.
• st64 r_buf_write(RBuffer *b, const ut8 *buf, ut64 len) — writes data to a buffer.
• st64 r_buf_seek(RBuffer *b, st64 addr, int whence) — seeks to a position in the buffer.
• ut64 r_buf_size(RBuffer *b) — returns the size of the buffer.

🎀 STRINGS 🎀

Common string helpers for allocation, concatenation, searching, replacement, and splitting. They make safe text manipulation and higher-level processing simpler and less error-prone — no cap.

• char * r_str_new(const char *str) — creates a new string (duplicate).
• char * r_str_append(char *str, const char *new) — appends a string to another.
• bool r_str_startswith(const char *str, const char *needle) — checks if a string starts with a prefix.
• char * r_str_replace(char *str, const char *find, const char *replace, int *count) — replaces substrings in a string.
• RList * r_str_split_list(char *str, const char *c, int n) — splits a string into a list.

🔗 LISTS 🔗

Lightweight linked-list utilities for creating, appending, indexing, and querying lists of pointers. Use these when a simple ordered collection is sufficient — it’s giving “just the basics, but make it useful.”

• RList * r_list_new(void) — creates a new linked list.
• void r_list_append(RList *list, void *data) — appends data to a list.
• void * r_list_get_n(RList *list, int n) — gets the nth element from a list.
• int r_list_length(RList *list) — returns the length of a list.

🧠 MEMORY 🧠

Convenience wrappers for allocating, duplicating, and comparing raw memory blocks. These helpers centralize routine memory tasks and can be adapted for custom allocator hooks or debugging instrumentation. Lowkey essential.

• void * r_mem_alloc(size_t sz) — allocates memory.
• void * r_mem_dup(const void *src, size_t len) — duplicates memory.
• int r_mem_cmp(const void *a, const void *b, size_t len) — compares memory regions.

📁 FILES 📁

Simple filesystem helpers to check existence, read entire files into memory, and write buffers to disk. Intended for straightforward file I/O needs in tools and utilities — periodt.

• bool r_file_exists(const char *str) — checks if a file exists.
• char * r_file_slurp(const char *str, size_t *usz) — reads an entire file into memory.
• bool r_file_dump(const char *file, const ut8 *buf, int len, bool append) — writes data to a file.

🔮 HEX 🔮

Routines to convert between hexadecimal text and binary data, commonly used when presenting or parsing hex-encoded blobs. Iykyk.

• int r_hex_str2bin(const char *str, ut8 *buf) — converts a hex string to binary.
• char * r_hex_bin2str(const ut8 *bin, int len) — converts binary data to a hex string.

🧚 BASE64 🧚

Utilities to encode binary data to base64 and decode it back, useful for transporting or embedding binary content in text contexts. Text-mode glow-up.

• int r_base64_encode(char *bout, const ut8 *bin, int len) — encodes data to base64.
• int r_base64_decode(ut8 *bout, const char *bin, int len, bool strict) — decodes base64 data. In strict mode any invalid character, misaligned length or misplaced padding fails with -1; otherwise invalid bytes are skipped and as much data as possible is recovered.
• ut8 * r_base64_decode_dyn(const char *in, int len, int *olen, bool strict) — decodes base64 data into a heap-allocated buffer, returning NULL on strict decoding failures.

🪞 TABLES 🪞

Helpers for building textual tables: create table objects, add columns and rows, and format output for display when presenting structured, columnar data. It’s giving “organized and cute.”

• RTable * r_table_new(void) — creates a new table.
• void r_table_add_column(RTable *t, RTableColumnType *type, const char *name, int maxwidth) — adds a column to a table.
• void r_table_add_row(RTable *t, const char *name, ...) — adds a row to a table.

🌈 GRAPHS 🌈

APIs to build and traverse basic graph structures made of nodes and edges. Suitable for representing relationships, control-flow, or dependency graphs — main character data structure.

• RGraph * r_graph_new(void) — creates a new graph.
• RGraphNode * r_graph_add_node(RGraph *graph, void *data) — adds a node to a graph.
• void r_graph_add_edge(RGraph *graph, RGraphNode *from, RGraphNode *to) — adds an edge between nodes.

🍓 QUEUES 🍓

A compact FIFO queue API for enqueuing and dequeuing pointer elements; useful in producer/consumer patterns and simple task scheduling. First in, first out, slay.

• RQueue * r_queue_new(int n) — creates a new queue.
• void r_queue_enqueue(RQueue *q, void *el) — enqueues an element.
• void * r_queue_dequeue(RQueue *q) — dequeues an element.

⭐ STACKS ⭐

A lightweight LIFO stack API for pushing and popping pointer elements, handy for depth-first traversals, undo stacks, and transient state storage. Last in, first out, iconic behavior.

• RStack * r_stack_new(ut32 n) — creates a new stack.
• void r_stack_push(RStack *s, void *el) — pushes an element onto the stack.
• void * r_stack_pop(RStack *s) — pops an element from the stack.

⏰ TIME ⏰

Helpers to obtain timestamps and format them as human-readable strings, used for logging, profiling, and displaying time-related information. Time is literally passing.

• ut64 r_time_now(void) — gets the current time in microseconds.
• char * r_time_stamp_to_str(ut64 ts) — converts a timestamp to a string.

📣 LOGGING 📣

Minimal logging helpers to emit error and informational messages, acting as thin wrappers for diagnostics and user-facing feedback. Not me being the group chat’s diagnostics queen.

• void r_log_error(const char *fmt, ...) — logs an error message.
• void r_log_info(const char *fmt, ...) — logs an info message.

🧪 EXAMPLES 🧪

Number parsing:

RNum *num = r_num_new(NULL, NULL, NULL);
ut64 val = r_num_get(num, "0x100");
r_num_free(num);

String manipulation:

char *str = r_str_new("hello");
str = r_str_append(str, " world");

Buffer operations:

RBuffer *buf = r_buf_new();
r_buf_write(buf, data, len);
ut8 *read_data = malloc(len);
r_buf_read(buf, read_data, len);

List usage:

RList *list = r_list_new();
r_list_append(list, item);
void *first = r_list_get_n(list, 0);

🫶 SEE ALSO 🫶

• r_types(3)

---

Cute sign-off bestie: this page came from Debian, dated September 20, 2025, and yes it’s the R_UTIL(3) manual page. Mwah 💋✨