/**
* type_var_new:
* @parent: parent object for new structure,
* @type: C type,
* @name: variable name.
*
* Allocates and returns a new TypeVar structure with the C type @type
* and variable name @name, the strucure is not placed into any linked
* list but will be removed from its containing list when freed.
*
* If @parent is not NULL, it should be a pointer to another object which
* will be used as a parent for the returned structure. When all parents
* of the returned structure are freed, the returned structure will also be
* freed.
*
* Returns: the new TypeVar structure or NULL if insufficient memory.
**/
TypeVar *
type_var_new (const void *parent,
const char *type,
const char *name)
{
TypeVar *var;
nih_assert (type != NULL);
nih_assert (name != NULL);
var = nih_new (parent, TypeVar);
if (! var)
return NULL;
nih_list_init (&var->entry);
var->type = nih_strdup (var, type);
if (! var->type) {
nih_free (var);
return NULL;
}
var->name = nih_strdup (var, name);
if (! var->name) {
nih_free (var);
return NULL;
}
var->array = FALSE;
nih_alloc_set_destructor (var, nih_list_destroy);
return var;
}
/**
* nih_error_push_context:
*
* Creates a new context in which errors can occur without disturbing any
* previous unhandled error, useful for touring a particular piece of
* processing that handles its own errors and may be triggered as a result
* of another error.
**/
void
nih_error_push_context (void)
{
NihErrorCtx *new_context;
nih_error_init ();
new_context = NIH_MUST (nih_new (context_stack, NihErrorCtx));
nih_list_init (&new_context->entry);
new_context->error = NULL;
nih_list_add (context_stack, &new_context->entry);
}
/**
* session_new:
* @parent: parent,
* @chroot: full chroot path,
* @user: user id.
*
* Create a new session.
*
* Return new Session, or NULL on error.
**/
Session *
session_new (const void *parent,
const char *chroot,
uid_t user)
{
Session *session;
nih_assert ((chroot != NULL) || (user != 0));
session_init ();
session = nih_new (parent, Session);
if (! session)
return NULL;
nih_list_init (&session->entry);
if (chroot) {
session->chroot = nih_strdup (session, chroot);
if (! session->chroot) {
nih_free (session);
return NULL;
}
} else {
session->chroot = NULL;
}
session->user = user;
session->conf_path = NULL;
nih_alloc_set_destructor (session, nih_list_destroy);
nih_list_add (sessions, &session->entry);
return session;
}
void
test_free (void)
{
void * ptr1;
void * ptr2;
Parent *parent;
int ret;
TEST_FUNCTION ("nih_free");
/* Check that nih_free works if the block has no parent. The
* destructor should get called and nih_free should return that
* return value.
*/
TEST_FEATURE ("with no parent");
ptr1 = nih_alloc (NULL, 10);
nih_alloc_set_destructor (ptr1, destructor_called);
destructor_was_called = 0;
ret = nih_free (ptr1);
TEST_TRUE (destructor_was_called);
TEST_EQ (ret, 2);
/* Check that nih_free works if the block has a parent. The
* destructor should get called and nih_free should return that
* return value.
*/
TEST_FEATURE ("with parent");
ptr2 = nih_alloc (NULL, 20);
ptr1 = nih_alloc (ptr2, 10);
nih_alloc_set_destructor (ptr1, destructor_called);
destructor_was_called = 0;
ret = nih_free (ptr1);
TEST_TRUE (destructor_was_called);
TEST_EQ (ret, 2);
nih_free (ptr2);
/* Check that the destructor on any children also gets called, which
* is as good a indication as any that the children are being freed.
*/
TEST_FEATURE ("with destructor on child");
ptr1 = nih_alloc (NULL, 10);
ptr2 = nih_alloc (ptr1, 10);
nih_alloc_set_destructor (ptr2, child_destructor_called);
child_destructor_was_called = 0;
ret = nih_free (ptr1);
TEST_TRUE (child_destructor_was_called);
TEST_EQ (ret, 0);
/* Check that both destructors on parent and children are called,
* and that the return value from nih_free is that of the parent's.
*/
TEST_FEATURE ("with child and destructors");
ptr1 = nih_alloc (NULL, 10);
ptr2 = nih_alloc (ptr1, 10);
nih_alloc_set_destructor (ptr1, destructor_called);
nih_alloc_set_destructor (ptr2, child_destructor_called);
destructor_was_called = 0;
child_destructor_was_called = 0;
ret = nih_free (ptr1);
TEST_TRUE (destructor_was_called);
TEST_TRUE (child_destructor_was_called);
TEST_EQ (ret, 2);
/* Check that a child of an object may be included in a sibling
* linked list allocated earlier. At the point the child destructor
* is called, the sibling must not have been freed otherwise it
* cannot cut itself out.
*/
TEST_FEATURE ("with child in older sibling list");
parent = nih_new (NULL, Parent);
__nih_malloc = my_list_head_malloc;
parent->list = nih_new (parent, NihList);
nih_list_init (parent->list);
__nih_malloc = malloc;
parent->child = nih_new (parent, Child);
nih_list_init (&parent->child->entry);
nih_list_add (parent->list, &parent->child->entry);
nih_alloc_set_destructor (parent->child, child_destructor_test);
__nih_free = my_list_head_free;
nih_free (parent);
__nih_free = free;
/* Check that a child of an object may be included in a sibling
* linked list allocated later. At the point the child destructor
* is called, the sibling must not have been freed otherwise it
* cannot cut itself out.
*/
TEST_FEATURE ("with child in younger sibling list");
parent = nih_new (NULL, Parent);
parent->child = nih_new (parent, Child);
nih_list_init (&parent->child->entry);
__nih_malloc = my_list_head_malloc;
parent->list = nih_new (parent, NihList);
nih_list_init (parent->list);
__nih_malloc = malloc;
nih_list_add (parent->list, &parent->child->entry);
nih_alloc_set_destructor (parent->child, child_destructor_test);
__nih_free = my_list_head_free;
nih_free (parent);
__nih_free = free;
}
int
main (int argc,
char *argv[])
{
NihList prototypes;
NihList typedefs;
NihList structs;
nih_local Interface *interface = NULL;
nih_local Property * property = NULL;
nih_local char * code = NULL;
nih_local char * block = NULL;
printf ("#include <dbus/dbus.h>\n"
"\n"
"#include <nih/macros.h>\n"
"#include <nih/alloc.h>\n"
"#include <nih/string.h>\n"
"#include <nih/logging.h>\n"
"#include <nih/error.h>\n"
"\n"
"#include <nih-dbus/dbus_error.h>\n"
"#include <nih-dbus/dbus_message.h>\n"
"#include <nih-dbus/dbus_object.h>\n"
"#include <nih-dbus/dbus_pending_data.h>\n"
"#include <nih-dbus/dbus_proxy.h>\n"
"#include <nih-dbus/errors.h>\n"
"\n"
"#include \"tests/interface_code.h\"\n"
"\n"
"\n");
interface = interface_new (NULL, "com.netsplit.Nih.Test");
interface->symbol = NULL;
property = property_new (interface, "name", "s", NIH_DBUS_READWRITE);
property->symbol = nih_strdup (property, "name");
nih_list_add (&interface->properties, &property->entry);
property = property_new (interface, "size", "u", NIH_DBUS_READWRITE);
property->symbol = nih_strdup (property, "size");
nih_list_add (&interface->properties, &property->entry);
nih_list_init (&prototypes);
nih_list_init (&structs);
interface->name = "com.netsplit.Nih.TestA";
code = interface_proxy_get_all_function (NULL, "my", interface,
&prototypes, &structs);
printf ("extern void my_com_netsplit_Nih_TestA_get_all_notify (DBusPendingCall *pending_call, "
"NihDBusPendingData *pending_data);\n");
printf ("\n");
printf ("%s"
"\n", code);
nih_list_init (&prototypes);
nih_list_init (&typedefs);
nih_list_init (&structs);
interface->name = "com.netsplit.Nih.Test";
code = interface_proxy_get_all_notify_function (NULL, "my", interface,
&prototypes, &typedefs,
&structs);
printf ("%s", code);
printf ("\n"
"\n");
nih_list_init (&prototypes);
nih_list_init (&structs);
code = interface_proxy_get_all_sync_function (NULL, "my", interface,
&prototypes, &structs);
printf ("%s"
"\n", code);
return 0;
}
