libsel4camkes/src/interface_registration.c - 3p/sel4/camkes-tool - Git at Google

 /*
  * Copyright 2020, Data61, CSIRO (ABN 41 687 119 230)
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */

 #include <assert.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stddef.h>

 #include <camkes/interface_registration.h>
 #include <utils/util.h>

 /* Could have used <utils/list.h> lists but that uses malloc by itself */

 /*
  * Two instances of linked lists structs, one nested inside the other.
  * E.g.
  *
  *     --------------------------        --------------------    --------------------
  *     | outer_interface_list_t | -----> | interface_list_t | -> | interface_list_t |
  *     --------------------------        --------------------    --------------------
  *                  |
  *                  V
  *     --------------------------        --------------------
  *     | outer_interface_list_t | -----> | interface_list_t | -> NULL
  *     --------------------------        --------------------
  *                  |
  *                  V
  *                 NULL
  */
 typedef struct interface_list interface_list_t;
 struct interface_list {
     void *interface_instance;
     char **properties;
     interface_list_t *next;
 };

 typedef struct outer_interface_list outer_interface_list_t;
 struct outer_interface_list {
     ps_interface_type_t interface_type;
     interface_list_t *interface_list;
     outer_interface_list_t *next;
 };

 typedef struct camkes_interface_cookie {
     ps_malloc_ops_t *malloc_ops;
     outer_interface_list_t *outer_interface_list;
 } camkes_interface_cookie_t;

 /* Only checks whether or not two interface list nodes are equal. 0 if they are
  * equal (interface_instances match), 1 otherwise. */
 static inline int interface_list_comparator(interface_list_t *a, interface_list_t *b)
 {
     assert(a && b);
     if (a->interface_instance == b->interface_instance) {
         return 0;
     }
     return 1;
 }

 SGLIB_DEFINE_LIST_PROTOTYPES(interface_list_t, interface_list_comparator, next);
 SGLIB_DEFINE_LIST_FUNCTIONS(interface_list_t, interface_list_comparator, next);

 static inline int outer_interface_list_comparator(outer_interface_list_t *a, outer_interface_list_t *b)
 {
     assert(a && b);
     if (a->interface_type == b->interface_type) {
         return 0;
     }
     return 1;
 }

 SGLIB_DEFINE_LIST_PROTOTYPES(outer_interface_list_t, outer_interface_list_comparator, next);
 SGLIB_DEFINE_LIST_FUNCTIONS(outer_interface_list_t, outer_interface_list_comparator, next);

 /* This is used to destroy any properties array that *we made a copy of* using copy_properties_array() */
 static inline void destroy_properties_array(ps_malloc_ops_t *malloc_ops, char **properties)
 {
     assert(malloc_ops);
     for (char *curr = *properties; curr != NULL; curr++) {
         size_t property_len = strlen(curr);
         ZF_LOGF_IF(ps_free(malloc_ops, property_len + 1, curr),
                    "Failed to cleanup properties from the properties array");
     }
 }

 static inline char **copy_properties_array(ps_malloc_ops_t *malloc_ops, char **properties)
 {
     assert(malloc_ops && properties);

     /* Find the amount of strings in the array */
     size_t num_strings = 0;
     for (char *curr = *properties; curr != NULL; curr++, num_strings++);

     char **properties_copy = NULL;
     int error = ps_calloc(malloc_ops, 1, sizeof(char *) * num_strings, (void **) &properties_copy);
     if (error) {
         return NULL;
     }

     /* Now go through the entire array and copy the strings */
     for (int i = 0; i < num_strings; i++) {
         size_t property_len = strlen(properties[i]);
         error = ps_calloc(malloc_ops, 1, sizeof(char) * property_len + 1, (void **) &properties_copy[i]);
         if (error) {
             ZF_LOGE("Failed to allocate property %d of %zu properties", i, num_strings);
             destroy_properties_array(malloc_ops, properties_copy);
             return NULL;
         }
         strncpy(properties_copy[i], properties[i], property_len + 1);
     }

     return properties_copy;
 }

 int camkes_interface_register(void *cookie, ps_interface_type_t interface_type, void *interface_instance,
                               char **properties)
 {
     if (!interface_instance && interface_type != PS_NULL_INTERFACE) {
         ZF_LOGE("Empty interface instance!");
         return -EINVAL;
     }

     int error = 0;
     int ret = 0;

     camkes_interface_cookie_t *interface_cookie = cookie;

     /* Check if there will be duplicate interface instances (same ptr) if we
      * add this new instance in */
     outer_interface_list_t dummy_outer_node = { .interface_type = interface_type };
     outer_interface_list_t *outer_member = sglib_outer_interface_list_t_find_member(interface_cookie->outer_interface_list,
                                                                                     &dummy_outer_node);
     bool allocated_outer_member = false;
     if (outer_member) {
         interface_list_t dummy_inner_node = { .interface_instance = interface_instance };
         interface_list_t *inner_member = sglib_interface_list_t_find_member(outer_member->interface_list,
                                                                             &dummy_inner_node);
         if (!inner_member) {
             /* Found a duplicate */
             ZF_LOGE("Trying to add the same interface instance into same interface type!");
             return -EINVAL;
         }
     } else {
         /* We now need to create a new outer list node for this interface type */
         error = ps_calloc(interface_cookie->malloc_ops, 1, sizeof(*outer_member), (void **) &outer_member);
         if (error) {
             ZF_LOGE("Failed to allocate memory for a new node for the interface type");
             return -ENOMEM;
         }
         /* Don't add it the of the outer interface list yet, as clean-up becomes problematic */
         outer_member->interface_type = interface_type;
         allocated_outer_member = true;
     }

     interface_list_t *new_node = NULL;
     error = ps_calloc(interface_cookie->malloc_ops, 1, sizeof(*new_node), (void **) &new_node);
     if (error) {
         ZF_LOGE("Failed to allocate memory for a new node for the interface instance");
         ret = -ENOMEM;
         goto fail;
     }

     char **properties_copy = NULL;
     if (properties) {
         char **properties_copy = copy_properties_array(interface_cookie->malloc_ops, properties);
         if (!properties_copy) {
             ret = -ENOMEM;
             goto fail;
         }
     }

     new_node->interface_instance = interface_instance;
     new_node->properties = properties_copy;

     sglib_interface_list_t_add(&outer_member->interface_list, new_node);

     if (allocated_outer_member) {
         /* Now we join this outer node into the outer list */
         sglib_outer_interface_list_t_add(&interface_cookie->outer_interface_list, outer_member);
     }

     return 0;

 fail:
     if (allocated_outer_member) {
         ZF_LOGF_IF(ps_free(interface_cookie->malloc_ops, sizeof(*outer_member), outer_member),
                    "Failed to cleanup after a failed interface register operation");
     }

     if (new_node) {
         ZF_LOGF_IF(ps_free(interface_cookie->malloc_ops, sizeof(*new_node), new_node),
                    "Failed to cleanup after a failed interface register operation");
     }

     return ret;
 }

 int camkes_interface_unregister(void *cookie, ps_interface_type_t interface_type, void *interface_instance)
 {
     if (!interface_instance && interface_type != PS_NULL_INTERFACE) {
         ZF_LOGE("Empty interface instance!");
         return -EINVAL;
     }

     camkes_interface_cookie_t *interface_cookie = cookie;

     /* Grab the outer node for this interface type */
     outer_interface_list_t dummy_outer_node = { .interface_type = interface_type };
     outer_interface_list_t *outer_member = sglib_outer_interface_list_t_find_member(interface_cookie->outer_interface_list,
                                                                                     &dummy_outer_node);
     if (!outer_member) {
         /* No outer node for this interface type, so that means that no
          * interface was ever registered for this type. Just ignore. */
         return 0;
     }

     interface_list_t dummy_node = { .interface_instance = interface_instance };
     interface_list_t *target_node = NULL;
     int deleted = sglib_interface_list_t_delete_if_member(&outer_member->interface_list, &dummy_node,
                                                           &target_node);
     if (deleted) {
         /* Only free memory if we've actually deleted something from the list,
          * also carry on as if nothing went wrong if we didn't delete aything
          * */
         if (target_node->properties) {
             destroy_properties_array(interface_cookie->malloc_ops, target_node->properties);
         }
         ZF_LOGF_IF(ps_free(interface_cookie->malloc_ops, sizeof(*target_node), target_node),
                    "Failed to free memory after unregistering an interface");
     }

     return 0;
 }

 int camkes_interface_find(void *cookie, ps_interface_type_t interface_type, ps_interface_search_handler_fn_t handler,
                           void *handler_data)
 {
     if (!handler) {
         ZF_LOGE("No handler provided!");
         return -EINVAL;
     }

     camkes_interface_cookie_t *interface_cookie = cookie;

     outer_interface_list_t dummy_node = { .interface_type = interface_type };
     outer_interface_list_t *outer_member = sglib_outer_interface_list_t_find_member(interface_cookie->outer_interface_list,
                                                                                     &dummy_node);
     if (!outer_member) {
         /* A list for this interface type does not exist yet and hence no entry
          * that we can look at */
         return -ENOENT;
     }

     int handler_ret = 0;

     for (interface_list_t *curr = outer_member->interface_list; curr != NULL; curr = curr->next) {
         handler_ret = handler(handler_data, curr->interface_instance, curr->properties);
         if (handler_ret < 0) {
             /* Error in the handler */
             return handler_ret;
         } else if (handler_ret == PS_INTERFACE_FOUND_MATCH) {
             /* Handler found a match */
             return 0;
         }
     }

     /* We've found no match whatsoever, so we return an error */
     return -ENOENT;
 }

 int camkes_interface_registration_ops(ps_interface_registration_ops_t *interface_ops, ps_malloc_ops_t *malloc_ops)
 {
     if (!interface_ops || !malloc_ops) {
         ZF_LOGE("Arguments are NULL!");
         return -EINVAL;
     }

     camkes_interface_cookie_t *cookie = NULL;
     int error = 0;

     error = ps_calloc(malloc_ops, 1, sizeof(camkes_interface_cookie_t), (void **) &cookie);
     if (error) {
         return -ENOMEM;
     }

     cookie->malloc_ops = malloc_ops;

     interface_ops->cookie = cookie;
     interface_ops->interface_register_fn = camkes_interface_register;
     interface_ops->interface_unregister_fn = camkes_interface_unregister;
     interface_ops->interface_find_fn = camkes_interface_find;

     return 0;
 }
	/*
	* Copyright 2020, Data61, CSIRO (ABN 41 687 119 230)
	*
	* SPDX-License-Identifier: BSD-2-Clause
	*/

	#include <assert.h>
	#include <errno.h>
	#include <stdbool.h>
	#include <string.h>
	#include <stddef.h>

	#include <camkes/interface_registration.h>
	#include <utils/util.h>

	/* Could have used <utils/list.h> lists but that uses malloc by itself */

	/*
	* Two instances of linked lists structs, one nested inside the other.
	* E.g.
	*
	* -------------------------- -------------------- --------------------
	* \| outer_interface_list_t \| -----> \| interface_list_t \| -> \| interface_list_t \|
	* -------------------------- -------------------- --------------------
	* \|
	* V
	* -------------------------- --------------------
	* \| outer_interface_list_t \| -----> \| interface_list_t \| -> NULL
	* -------------------------- --------------------
	* \|
	* V
	* NULL
	*/
	typedef struct interface_list interface_list_t;
	struct interface_list {
	void *interface_instance;
	char **properties;
	interface_list_t *next;
	};

	typedef struct outer_interface_list outer_interface_list_t;
	struct outer_interface_list {
	ps_interface_type_t interface_type;
	interface_list_t *interface_list;
	outer_interface_list_t *next;
	};

	typedef struct camkes_interface_cookie {
	ps_malloc_ops_t *malloc_ops;
	outer_interface_list_t *outer_interface_list;
	} camkes_interface_cookie_t;

	/* Only checks whether or not two interface list nodes are equal. 0 if they are
	* equal (interface_instances match), 1 otherwise. */
	static inline int interface_list_comparator(interface_list_t a, interface_list_t b)
	{
	assert(a && b);
	if (a->interface_instance == b->interface_instance) {
	return 0;
	}
	return 1;
	}

	SGLIB_DEFINE_LIST_PROTOTYPES(interface_list_t, interface_list_comparator, next);
	SGLIB_DEFINE_LIST_FUNCTIONS(interface_list_t, interface_list_comparator, next);

	static inline int outer_interface_list_comparator(outer_interface_list_t a, outer_interface_list_t b)
	{
	assert(a && b);
	if (a->interface_type == b->interface_type) {
	return 0;
	}
	return 1;
	}

	SGLIB_DEFINE_LIST_PROTOTYPES(outer_interface_list_t, outer_interface_list_comparator, next);
	SGLIB_DEFINE_LIST_FUNCTIONS(outer_interface_list_t, outer_interface_list_comparator, next);

	/* This is used to destroy any properties array that we made a copy of using copy_properties_array() */
	static inline void destroy_properties_array(ps_malloc_ops_t malloc_ops, char *properties)
	{
	assert(malloc_ops);
	for (char curr = properties; curr != NULL; curr++) {
	size_t property_len = strlen(curr);
	ZF_LOGF_IF(ps_free(malloc_ops, property_len + 1, curr),
	"Failed to cleanup properties from the properties array");
	}
	}

	static inline char *copy_properties_array(ps_malloc_ops_t malloc_ops, char **properties)
	{
	assert(malloc_ops && properties);

	/* Find the amount of strings in the array */
	size_t num_strings = 0;
	for (char curr = properties; curr != NULL; curr++, num_strings++);

	char **properties_copy = NULL;
	int error = ps_calloc(malloc_ops, 1, sizeof(char ) num_strings, (void **) &properties_copy);
	if (error) {
	return NULL;
	}

	/* Now go through the entire array and copy the strings */
	for (int i = 0; i < num_strings; i++) {
	size_t property_len = strlen(properties[i]);
	error = ps_calloc(malloc_ops, 1, sizeof(char) * property_len + 1, (void **) &properties_copy[i]);
	if (error) {
	ZF_LOGE("Failed to allocate property %d of %zu properties", i, num_strings);
	destroy_properties_array(malloc_ops, properties_copy);
	return NULL;
	}
	strncpy(properties_copy[i], properties[i], property_len + 1);
	}

	return properties_copy;
	}

	int camkes_interface_register(void cookie, ps_interface_type_t interface_type, void interface_instance,
	char **properties)
	{
	if (!interface_instance && interface_type != PS_NULL_INTERFACE) {
	ZF_LOGE("Empty interface instance!");
	return -EINVAL;
	}

	int error = 0;
	int ret = 0;

	camkes_interface_cookie_t *interface_cookie = cookie;

	/* Check if there will be duplicate interface instances (same ptr) if we
	* add this new instance in */
	outer_interface_list_t dummy_outer_node = { .interface_type = interface_type };
	outer_interface_list_t *outer_member = sglib_outer_interface_list_t_find_member(interface_cookie->outer_interface_list,
	&dummy_outer_node);
	bool allocated_outer_member = false;
	if (outer_member) {
	interface_list_t dummy_inner_node = { .interface_instance = interface_instance };
	interface_list_t *inner_member = sglib_interface_list_t_find_member(outer_member->interface_list,
	&dummy_inner_node);
	if (!inner_member) {
	/* Found a duplicate */
	ZF_LOGE("Trying to add the same interface instance into same interface type!");
	return -EINVAL;
	}
	} else {
	/* We now need to create a new outer list node for this interface type */
	error = ps_calloc(interface_cookie->malloc_ops, 1, sizeof(outer_member), (void *) &outer_member);
	if (error) {
	ZF_LOGE("Failed to allocate memory for a new node for the interface type");
	return -ENOMEM;
	}
	/* Don't add it the of the outer interface list yet, as clean-up becomes problematic */
	outer_member->interface_type = interface_type;
	allocated_outer_member = true;
	}

	interface_list_t *new_node = NULL;
	error = ps_calloc(interface_cookie->malloc_ops, 1, sizeof(new_node), (void *) &new_node);
	if (error) {
	ZF_LOGE("Failed to allocate memory for a new node for the interface instance");
	ret = -ENOMEM;
	goto fail;
	}

	char **properties_copy = NULL;
	if (properties) {
	char **properties_copy = copy_properties_array(interface_cookie->malloc_ops, properties);
	if (!properties_copy) {
	ret = -ENOMEM;
	goto fail;
	}
	}

	new_node->interface_instance = interface_instance;
	new_node->properties = properties_copy;

	sglib_interface_list_t_add(&outer_member->interface_list, new_node);

	if (allocated_outer_member) {
	/* Now we join this outer node into the outer list */
	sglib_outer_interface_list_t_add(&interface_cookie->outer_interface_list, outer_member);
	}

	return 0;

	fail:
	if (allocated_outer_member) {
	ZF_LOGF_IF(ps_free(interface_cookie->malloc_ops, sizeof(*outer_member), outer_member),
	"Failed to cleanup after a failed interface register operation");
	}

	if (new_node) {
	ZF_LOGF_IF(ps_free(interface_cookie->malloc_ops, sizeof(*new_node), new_node),
	"Failed to cleanup after a failed interface register operation");
	}

	return ret;
	}

	int camkes_interface_unregister(void cookie, ps_interface_type_t interface_type, void interface_instance)
	{
	if (!interface_instance && interface_type != PS_NULL_INTERFACE) {
	ZF_LOGE("Empty interface instance!");
	return -EINVAL;
	}

	camkes_interface_cookie_t *interface_cookie = cookie;

	/* Grab the outer node for this interface type */
	outer_interface_list_t dummy_outer_node = { .interface_type = interface_type };
	outer_interface_list_t *outer_member = sglib_outer_interface_list_t_find_member(interface_cookie->outer_interface_list,
	&dummy_outer_node);
	if (!outer_member) {
	/* No outer node for this interface type, so that means that no
	* interface was ever registered for this type. Just ignore. */
	return 0;
	}

	interface_list_t dummy_node = { .interface_instance = interface_instance };
	interface_list_t *target_node = NULL;
	int deleted = sglib_interface_list_t_delete_if_member(&outer_member->interface_list, &dummy_node,
	&target_node);
	if (deleted) {
	/* Only free memory if we've actually deleted something from the list,
	* also carry on as if nothing went wrong if we didn't delete aything
	* */
	if (target_node->properties) {
	destroy_properties_array(interface_cookie->malloc_ops, target_node->properties);
	}
	ZF_LOGF_IF(ps_free(interface_cookie->malloc_ops, sizeof(*target_node), target_node),
	"Failed to free memory after unregistering an interface");
	}

	return 0;
	}

	int camkes_interface_find(void *cookie, ps_interface_type_t interface_type, ps_interface_search_handler_fn_t handler,
	void *handler_data)
	{
	if (!handler) {
	ZF_LOGE("No handler provided!");
	return -EINVAL;
	}

	camkes_interface_cookie_t *interface_cookie = cookie;

	outer_interface_list_t dummy_node = { .interface_type = interface_type };
	outer_interface_list_t *outer_member = sglib_outer_interface_list_t_find_member(interface_cookie->outer_interface_list,
	&dummy_node);
	if (!outer_member) {
	/* A list for this interface type does not exist yet and hence no entry
	* that we can look at */
	return -ENOENT;
	}

	int handler_ret = 0;

	for (interface_list_t *curr = outer_member->interface_list; curr != NULL; curr = curr->next) {
	handler_ret = handler(handler_data, curr->interface_instance, curr->properties);
	if (handler_ret < 0) {
	/* Error in the handler */
	return handler_ret;
	} else if (handler_ret == PS_INTERFACE_FOUND_MATCH) {
	/* Handler found a match */
	return 0;
	}
	}

	/* We've found no match whatsoever, so we return an error */
	return -ENOENT;
	}

	int camkes_interface_registration_ops(ps_interface_registration_ops_t interface_ops, ps_malloc_ops_t malloc_ops)
	{
	if (!interface_ops \|\| !malloc_ops) {
	ZF_LOGE("Arguments are NULL!");
	return -EINVAL;
	}

	camkes_interface_cookie_t *cookie = NULL;
	int error = 0;

	error = ps_calloc(malloc_ops, 1, sizeof(camkes_interface_cookie_t), (void **) &cookie);
	if (error) {
	return -ENOMEM;
	}

	cookie->malloc_ops = malloc_ops;

	interface_ops->cookie = cookie;
	interface_ops->interface_register_fn = camkes_interface_register;
	interface_ops->interface_unregister_fn = camkes_interface_unregister;
	interface_ops->interface_find_fn = camkes_interface_find;

	return 0;
	}