libtalloc_dts(3) [centos man page]

libtalloc_dts(3)						      talloc							  libtalloc_dts(3)

NAME

       libtalloc_dts - Chapter 3: Dynamic type system

Dynamic type system
       Generic programming in the C language is very difficult. There is no inheritance nor templates known from object oriented languages. There
       is no dynamic type system. Therefore, generic programming in this language is usually done by type-casting a variable to void* and
       transferring it through a generic function to a specialized callback as illustrated on the 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);
       }

       Unfortunately, the type information is lost as a result of this type cast. The compiler cannot check the type during the compilation nor
       are we able to do it at runtime. Providing an invalid data type to the callback will result in unexpected behaviour (not necessarily a
       crash) of the application. This mistake is usually hard to detect because it is not the first thing which comes the mind.

       As we already know, every talloc context contains a name. This name is available at any time and it can be used to determine the type of a
       context even if we lose the type of a variable.

       Although 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.

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

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

       o talloc_get_type()

       o talloc_get_type_abort()

Examples
       The following example will show how generic programming with talloc is handled - if we provide invalid data to the callback, the program
       will be aborted. This is 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 are creating a service application that should be running for the uptime of a server, 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: %s0, reason);
       #ifdef ABORT_ON_TYPE_MISMATCH
	 abort();
       #endif
       }

       The usage of talloc_get_type_abort() would be then:

       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] */

Version 2.0							  Tue Jun 17 2014						  libtalloc_dts(3)

Check Out this Related Man Page

libtalloc_stealing(3)						      talloc						     libtalloc_stealing(3)

NAME

       libtalloc_stealing - Chapter 2: Stealing a context

Stealing a context
       Talloc has the ability to change the parent of a talloc context to another one. This operation is commonly referred to as stealing and it
       is one of the most important actions performed with talloc contexts.

       Stealing a context is necessary if we want the pointer to outlive the context it is created on. This has many possible use cases, for
       instance stealing a result of a database search to an in-memory cache context, changing the parent of a field of a generic structure to a
       more specific one or vice-versa. The most common scenario, at least in Samba, is to steal output data from a function-specific context to
       the output context given as an argument of that function.

       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 talloc_move() function is similar to the talloc_steal() function but additionally sets the source pointer to NULL.

       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 is assigned to another variable, thus further accessing the pointer from the original variable should be avoided unless it is
       necessary. In this case talloc_move() is the preferred way of stealing a context. Additionally sets the source pointer to NULL,
       thus.protects the pointer from being accidentally freed and accessed using the old variable after its parent has been changed.

Version 2.0							  Tue Jun 17 2014					     libtalloc_stealing(3)

Linux and UNIX Man Pages

libtalloc_dts(3) [centos man page]

Check Out this Related Man Page