libtalloc_dts(3)

💖 NAME 💖

libtalloc_dts — bestie, this is Chapter 3: Dynamic type system of the libtalloc manual (that's the Library Functions Manual page, section 3, iykyk).

---

🦋 Dynamic type system 🦋

okay so real talk: generic programming in the C language is very difficult. There's no inheritance, no templates like the object oriented girlies get. There is no dynamic type system. periodt. So what do people usually do? They type-cast a variable to void* and pass it through a generic function over to a specialized callback, exactly like this next listing:

void generic_function(callback_fn cb, void *pvt)
{
  /* do some stuff and call the callback */
  cb(pvt);
}

void specific_callback(void *pvt)
{
  struct specific_struct *data;
  data = (struct specific_struct*)pvt;
  /* ... */
}

void specific_function()
{
  struct specific_struct data;
  generic_function(callback, &data);
}

And like... unfortunately the type information is lost as a result of that type cast. 😭 The compiler cannot check the type during compilation, and neither can we do it at runtime. If you hand an invalid data type to the callback, you get unexpected behaviour (not necessarily a crash, which is somehow worse 💀) from your application. And this mistake is usually hard to detect because it's genuinely not the first thing that comes to mind.

But!! As we already know, every talloc context contains a name. That name is available at any time, and it can be used to determine the type of a context even when we've lost the type of a variable. slay.

So even though the name of the context can be set to any arbitrary string, the best way of using it to simulate the dynamic type system is to set it directly to the type of the variable. no cap.

It is recommended to use one of talloc() and talloc_array() (or its variants) to create the context, because they set its name to the name of the given type automatically. obsessed.

So if we have a context with such a name, we can use two similar functions that do both the type check and the type cast for us:

• talloc_get_type()
• talloc_get_type_abort()

---

✨ Examples ✨

The following example shows how generic programming with talloc is handled — if we provide invalid data to the callback, the program will be aborted. That's a sufficient reaction for such an error in most applications.

void foo_callback(void *pvt)
{
  struct foo *data = talloc_get_type_abort(pvt, struct foo);
  /* ... */
}

int do_foo()
{
  struct foo *data = talloc_zero(NULL, struct foo);
  /* ... */
  return generic_function(foo_callback, data);
}

But what if we're creating a service application that should be running for the uptime of a server? 👀 Then we may want to abort the application during the development process (to make sure the error is not overlooked) and try to recover from the error in the customer release. This can be achieved by creating a custom abort function with a conditional build:

void my_abort(const char *reason)
{
  fprintf(stderr, "talloc abort: %s\n", reason);
#ifdef ABORT_ON_TYPE_MISMATCH
  abort();
#endif
}

The usage of talloc_get_type_abort() would then be:

talloc_set_abort_fn(my_abort);

TALLOC_CTX *ctx = talloc_new(NULL);
char *str = talloc_get_type_abort(ctx, char);
if (str == NULL) {
  /* recovery code */
}
/* talloc abort: ../src/main.c:25: Type mismatch:
   name[talloc_new: ../src/main.c:24] expected[char] */

---

fr fr, that type mismatch message is literally giving you the name of the context and the expected type. read it. 💅

that's the whole chapter, bestie — go forth and type-check responsibly 🫶

💖 this page is libtalloc_dts(3) from talloc Version 2.0 (Library Functions Manual, section 3) — mwah, thanks for reading, ily ✨🎀🦋