libtalloc_stealing(3)

💖 libtalloc_stealing 💖

okay bestie so this is the libtalloc_stealing page from the talloc library functions manual — it's literally Chapter 2: Stealing a context and it's about to change ur whole talloc life, no cap 🎀

---

✨ Stealing a context ✨

so talloc has this iconic ability to change the parent of a talloc context into a whole different one. this move is what we call stealing and honestly? it's one of the most important actions you can perform with talloc contexts. main character behaviour fr fr 💅

stealing a context is necessary when you want the pointer to outlive the context it was created on. and the use cases?? so many, bestie:

• stealing the result of a database search into an in-memory cache context
• changing the parent of a field of a generic structure to a more specific one
• ...or the other way around, vice-versa, whatever the vibe needs

and the most common scenario, at least in Samba, is stealing output data from a function-specific context into the output context that got passed as an argument of that function. iykyk 🦋

---

🧚 the code, verbatim, don't touch a single character

struct foo {
    char *a1;
    char *a2;
    char *a3;
};

struct bar {
    char *wurst;
    struct foo *foo;
};

struct foo *foo = talloc_zero(ctx, struct foo);
foo->a1 = talloc_strdup(foo, "a1");
foo->a2 = talloc_strdup(foo, "a2");
foo->a3 = talloc_strdup(foo, "a3");

struct bar *bar = talloc_zero(NULL, struct bar);
/* change parent of foo from ctx to bar */
bar->foo = talloc_steal(bar, foo);

/* or do the same but assign foo = NULL */
bar->foo = talloc_move(bar, &foo);

---

🌸 the two queens: talloc_steal() and talloc_move()

so the talloc_move() function is similar to the talloc_steal() function, except it ALSO sets the source pointer to NULL. that's the whole difference, that's it, that's the tea ☕✨

---

⭐ ok but about that source pointer

in general, the source pointer itself is not changed — it only replaces the parent in the meta data. but the common usage is that the result gets assigned to another variable, so further accessing the pointer from the original variable should be avoided unless it's necessary.

and in that case? talloc_move() is the preferred way of stealing a context. it additionally sets the source pointer to NULL, which protects the pointer from being accidentally freed and accessed using the old variable after its parent has been changed. lowkey a glow-up for ur safety 🔥

bestie warning: if you steal and then keep poking the old variable, that's a vibe check you will fail. use talloc_move() when you can 💀

---

and that's the whole page, periodt. this was libtalloc_stealing(3) from the talloc manual, Version 2.0 — mwah, tysm for reading, stay hydrated, go steal some contexts responsibly 🫶👑🌈