denozord/strongswan-ext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- return value cleanup

Browse Source
This commit is contained in:
Martin Willi
2005-11-28 20:29:47 +00:00
parent 3fe058703f
commit d048df5cab
85 changed files with 1086 additions and 2680 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/charon/utils/gmp_helper.c
+55 -164
View File
@@ -44,7 +44,6 @@ struct private_gmp_helper_t {
* Public gmp_helper_t interface.
*/
gmp_helper_t public;
};
@@ -53,186 +52,83 @@ struct private_gmp_helper_t {
*/
static void chunk_to_mpz(private_gmp_helper_t *this, mpz_t *mpz_value, chunk_t data)
{
size_t i;
mpz_init_set_ui(*(mpz_value), 0);
for (i = 0; i < data.len; i++)
{
size_t i;
mpz_init_set_ui(*(mpz_value), 0);
for (i = 0; i < data.len; i++)
{
mpz_mul_ui(*(mpz_value),*(mpz_value), 1 << 8);
mpz_add_ui(*(mpz_value),*(mpz_value), data.ptr[i]);
}
}
}
/**
* Implementation of gmp_helper_t.mpz_to_chunk.
*/
static status_t mpz_to_chunk (private_gmp_helper_t *this,mpz_t *mpz_value, chunk_t *data,size_t bytes)
static void mpz_to_chunk (private_gmp_helper_t *this,mpz_t *mpz_value, chunk_t *data,size_t bytes)
{
mpz_t temp1, temp2;
status_t status = SUCCESS;
int i;
chunk_t tmp_chunk;
tmp_chunk.len = bytes;
tmp_chunk.ptr = allocator_alloc(tmp_chunk.len);
if (tmp_chunk.ptr == NULL)
{
allocator_free_chunk(&tmp_chunk);
return OUT_OF_RES;
}
/* free memory */
memset(tmp_chunk.ptr,0,tmp_chunk.len);
mpz_init(temp1);
mpz_init(temp2);
mpz_set(temp1, *mpz_value);
for (i = tmp_chunk.len-1; i >= 0; i--)
{
mpz_t temp1, temp2;
int i;
chunk_t tmp_chunk;
tmp_chunk.len = bytes;
tmp_chunk.ptr = allocator_alloc(tmp_chunk.len);
memset(tmp_chunk.ptr,0,tmp_chunk.len);
mpz_init(temp1);
mpz_init(temp2);
mpz_set(temp1, *mpz_value);
for (i = tmp_chunk.len-1; i >= 0; i--)
{
tmp_chunk.ptr[i] = mpz_mdivmod_ui(temp2, NULL, temp1, 1 << 8);
mpz_set(temp1, temp2);
}
if (mpz_sgn(temp1) != 0)
{
fprintf (stderr,"value %d\n",mpz_sgn(temp1));
status = FAILED;
}
mpz_clear(temp1);
mpz_clear(temp2);
*data = tmp_chunk;
if (status != SUCCESS)
{
allocator_free_chunk(&tmp_chunk);
}
return status;
mpz_clear(temp1);
mpz_clear(temp2);
*data = tmp_chunk;
}
/**
* Implementation of gmp_helper_t.init_prime.
*/
static status_t init_prime (private_gmp_helper_t *this, mpz_t *prime, int bytes)
static void init_prime (private_gmp_helper_t *this, mpz_t *prime, int bytes)
{
randomizer_t *randomizer;
chunk_t random_bytes;
status_t status;
randomizer = randomizer_create();
if (randomizer == NULL)
{
return OUT_OF_RES;
}
/* TODO change to true random device ? */
//status = randomizer->allocate_random_bytes(randomizer,bytes, &random_bytes);
status = randomizer->allocate_pseudo_random_bytes(randomizer,bytes, &random_bytes);
/* make sure most significant bit is set */
random_bytes.ptr[0] = random_bytes.ptr[0] | 0x80;
/* not needed anymore */
randomizer->destroy(randomizer);
/* convert chunk to mpz value */
this->public.chunk_to_mpz(&(this->public),prime, random_bytes);
/* chunk is not used anymore */
allocator_free(random_bytes.ptr);
random_bytes.ptr = NULL;
randomizer_t *randomizer;
chunk_t random_bytes;
randomizer = randomizer_create();
/* TODO change to true random device ? */
//randomizer->allocate_random_bytes(randomizer,bytes, &random_bytes);
randomizer->allocate_pseudo_random_bytes(randomizer,bytes, &random_bytes);
/* make sure most significant bit is set */
random_bytes.ptr[0] = random_bytes.ptr[0] | 0x80;
/* not needed anymore */
randomizer->destroy(randomizer);
/* convert chunk to mpz value */
this->public.chunk_to_mpz(&(this->public),prime, random_bytes);
/* chunk is not used anymore */
allocator_free(random_bytes.ptr);
random_bytes.ptr = NULL;
/* composites are possible but should never occur */
mpz_nextprime (*(prime),*(prime));
return SUCCESS;
}
/**
* Implementation of gmp_helper_t.init_prime_fast.
*/
static status_t init_prime_fast (private_gmp_helper_t *this, mpz_t *prime, int bytes){
randomizer_t *randomizer;
chunk_t random_bytes;
status_t status;
unsigned long tries;
size_t length;
randomizer = randomizer_create();
if (randomizer == NULL)
{
return OUT_OF_RES;
}
/* TODO change to true random device ? */
//status = randomizer->allocate_random_bytes(randomizer,bytes, &random_bytes);
status = randomizer->allocate_pseudo_random_bytes(randomizer,bytes, &random_bytes);
/* make sure most significant bit is set */
random_bytes.ptr[0] = random_bytes.ptr[0] | 0x80;
/* not needed anymore */
randomizer->destroy(randomizer);
/* convert chunk to mpz value */
this->public.chunk_to_mpz(&(this->public),prime, random_bytes);
/* chunk is not used anymore */
allocator_free(random_bytes.ptr);
random_bytes.ptr = NULL;
/* make value odd */
if (mpz_fdiv_ui(*prime, 2) != 1)
{
/* make value odd */
mpz_add_ui(*prime,*prime,1);
}
tries = 1;
/* starting find a prime */
while (!mpz_probab_prime_p(*prime, PRIMECHECK_ROUNDS))
{
/* not a prime, increase by 2 */
mpz_add_ui(*prime, *prime, 2);
tries++;
}
length = mpz_sizeinbase(*prime, 2);
/* check bit length of prime */
if ((length < (bytes * 8)) || (length > ((bytes * 8) + 1)))
{
return FAILED;
}
if (length == ((bytes * 8) + 1))
{
/* carry out occured! retry */
mpz_clear(*prime);
/* recursive call */
return this->public.init_prime_fast(&(this->public),prime, bytes);
}
return SUCCESS;
}
/**
* Implementation of gmp_helper_t.destroy.
*/
static status_t destroy(private_gmp_helper_t *this)
static void destroy(private_gmp_helper_t *this)
{
allocator_free(this);
return SUCCESS;
}
/*
@@ -241,19 +137,14 @@ static status_t destroy(private_gmp_helper_t *this)
gmp_helper_t *gmp_helper_create()
{
private_gmp_helper_t *this = allocator_alloc_thing(private_gmp_helper_t);
if ((this == NULL))
{
return NULL;
}
/* public functions */
this->public.destroy = (status_t (*)(gmp_helper_t *)) destroy;
this->public.init_prime = (status_t (*) (gmp_helper_t *, mpz_t *, int)) init_prime;
this->public.init_prime_fast = (status_t (*) (gmp_helper_t *, mpz_t *, int)) init_prime_fast;
this->public.destroy = (void (*)(gmp_helper_t *)) destroy;
this->public.init_prime = (void (*) (gmp_helper_t *, mpz_t *, int)) init_prime;
/* private functions */
/* private functions */
this->public.chunk_to_mpz = (void (*) (gmp_helper_t *,mpz_t *, chunk_t )) chunk_to_mpz;
this->public.mpz_to_chunk = (status_t (*) (gmp_helper_t *,mpz_t *, chunk_t *,size_t )) mpz_to_chunk;
this->public.mpz_to_chunk = (void (*) (gmp_helper_t *,mpz_t *, chunk_t *,size_t )) mpz_to_chunk;
return &(this->public);
}
Source/charon/utils/gmp_helper.h
+6 -31
View File
@@ -47,26 +47,8 @@ struct gmp_helper_t {
* @param this calling object
* @param[out] var pointer to mpz_t variable to initialize
* @param[in] bytes length of given prime in bytes
* @return
* - SUCCCESS
* - OUT_OF_RES
*/
status_t (*init_prime) (gmp_helper_t *this, mpz_t *var, int bytes);
/**
* Initialize an mpz_t to a random prime of specified size without using gmp
* next prime function.
*
*
* @param this calling object
* @param[out] var mpz_t variable to initialize
* @param[in] bytes length of given prime in bytes
* @return
* - SUCCCESS
* - FAILED if length of prime not as asked. Try again.
* - OUT_OF_RES
*/
status_t (*init_prime_fast) (gmp_helper_t *this, mpz_t *prime, int bytes);
void (*init_prime) (gmp_helper_t *this, mpz_t *var, int bytes);
/**
* Convert network form (binary bytes, big-endian) to mpz_t of gmp library.
@@ -74,7 +56,7 @@ struct gmp_helper_t {
* The given mpz_t gets initialized in this function.
*
* @param this calling private_gmp_helper_t object
* @param mpz_value pointer to a mpz_t value
* @param mpz_value pointer to a mpz_t value
* @param data chunk_t containing the network form of data
*/
void (*chunk_to_mpz) (gmp_helper_t *this,mpz_t *mpz_value, chunk_t data);
@@ -83,16 +65,11 @@ struct gmp_helper_t {
* Convert mpz_t to network form (binary bytes, big-endian).
*
* @param this calling private_gmp_helper_t object
* @param mpz_value mpz_value to convert
* @param mpz_value mpz_value to convert
* @param data chunk_t where the data are written to
* @param bytes number of bytes to copy
*
* @return
* - SUCCESS
* - OUT_OF_RES
* - FAILED if mpz_t value was longer then given bytes count
*/
status_t (*mpz_to_chunk) (gmp_helper_t *this,mpz_t *mpz_value, chunk_t *data,size_t bytes);
void (*mpz_to_chunk) (gmp_helper_t *this, mpz_t *mpz_value, chunk_t *data, size_t bytes);
/**
* @brief Destroys an gmp_helper_t object.
@@ -100,15 +77,13 @@ struct gmp_helper_t {
* @param this gmp_helper_t object to destroy
* @return SUCCESS in any case
*/
status_t (*destroy) (gmp_helper_t *this);
void (*destroy) (gmp_helper_t *this);
};
/**
* Creates a new gmp_helper_t object
*
* @return
* - gmp_helper_t object
* - NULL if out of ressources
* @return gmp_helper_t object
*
* @ingroup utils
*/
Source/charon/utils/iterator.h
+7 -13
View File
@@ -52,7 +52,7 @@ struct iterator_t {
* @param[out] value value is set to the current value at iterator position
* @return
* - SUCCESS
* - FAILED if list is empty
* - FAILED if iterator on an invalid position
*/
status_t (*current) (iterator_t *this, void **value);
@@ -63,24 +63,18 @@ struct iterator_t {
*
* @param this calling iterator
* @param[in] item value to insert in list
* @return
* - SUCCESS
* - FAILED
*/
status_t (*insert_before) (iterator_t *this, void *item);
void (*insert_before) (iterator_t *this, void *item);
/**
* Inserts a new item after the given iterator position.
* @brief Inserts a new item after the given iterator position.
*
* The iterator position is not changed after inserting.
*
* @param this calling iterator
* @param[in] item value to insert in list
* @return
* - SUCCESS
* - FAILED
*/
status_t (*insert_after) (iterator_t *this, void *item);
void (*insert_after) (iterator_t *this, void *item);
/**
* @brief removes an element from list at the given iterator position.
@@ -93,7 +87,7 @@ struct iterator_t {
* @param linked_list calling object
* @return
* - SUCCESS
* - FAILED
* - FAILED if iterator is on an invalid position
*/
status_t (*remove) (iterator_t *iterator);
@@ -107,7 +101,7 @@ struct iterator_t {
* @param this calling object
* @return SUCCESS in any case
*/
status_t (*reset) (iterator_t *this);
void (*reset) (iterator_t *this);
/**
* @brief Destroys an iterator.
@@ -116,7 +110,7 @@ struct iterator_t {
* @return SUCCESS in any case
*
*/
status_t (*destroy) (iterator_t *this);
void (*destroy) (iterator_t *this);
};
#endif /*ITERATOR_H_*/
Source/charon/utils/linked_list.c
+40 -105
View File
@@ -40,33 +40,32 @@ struct linked_list_element_t {
*/
void *value;
/**
* Destroys a linked_list_element object.
*
* @param linked_list_element_t calling object
* @returns SUCCESS in any case
*/
status_t (*destroy) (linked_list_element_t *this);
/**
* previous list element
* NULL if first element in list
*/
linked_list_element_t *previous;
/**
* next list element
* NULL if last element in list
*/
linked_list_element_t *next;
/**
* Destroys a linked_list_element object.
*
* @param linked_list_element_t calling object
*/
void (*destroy) (linked_list_element_t *this);
};
/**
* Implementation of linked_list_element_t.destroy.
*/
static status_t linked_list_element_destroy(linked_list_element_t *this)
static void linked_list_element_destroy(linked_list_element_t *this)
{
allocator_free(this);
return SUCCESS;
}
/**
@@ -74,21 +73,14 @@ static status_t linked_list_element_destroy(linked_list_element_t *this)
*
* @warning Only the pointer to the value is stored.
*
* @param[in] value value of item to be set
* @return
* - linked_list_element_t object
* - NULL if out of ressources
* @param[in] value value of item to be set
* @return linked_list_element_t object
*/
linked_list_element_t *linked_list_element_create(void *value)
{
linked_list_element_t *this = allocator_alloc_thing(linked_list_element_t);
if (this == NULL)
{
return NULL;
}
this->destroy = linked_list_element_destroy;
this->previous=NULL;
@@ -120,6 +112,7 @@ struct private_linked_list_t {
* NULL if no elements in list.
*/
linked_list_element_t *first;
/**
* Last element in list.
* NULL if no elements in list.
@@ -132,7 +125,6 @@ typedef struct private_iterator_t private_iterator_t;
/**
* Private variables and functions of linked list iterator.
*
*/
struct private_iterator_t {
/**
@@ -204,10 +196,9 @@ static status_t iterator_current(private_iterator_t *this, void **value)
/**
* Implementation of iterator_t.reset.
*/
static status_t iterator_reset(private_iterator_t *this)
static void iterator_reset(private_iterator_t *this)
{
this->current = NULL;
return SUCCESS;
}
/**
@@ -275,28 +266,17 @@ static status_t remove(private_iterator_t *this)
/**
* Implementation of iterator_t.insert_before.
*/
static status_t insert_before(private_iterator_t * iterator, void *item)
static void insert_before(private_iterator_t * iterator, void *item)
{
if (iterator->current == NULL)
{
return (iterator->list->public.insert_first(&(iterator->list->public), item));
iterator->list->public.insert_first(&(iterator->list->public), item);
}
linked_list_element_t *element =(linked_list_element_t *) linked_list_element_create(item);
if (element == NULL)
{
return OUT_OF_RES;
}
if (iterator->current->previous == NULL)
{
if (iterator->list->first != iterator->current)
{
element->destroy(element);
return FAILED;
}
iterator->current->previous = element;
element->next = iterator->current;
iterator->list->first = element;
@@ -310,35 +290,22 @@ static status_t insert_before(private_iterator_t * iterator, void *item)
}
iterator->list->count++;
return SUCCESS;
}
/**
* Implementation of iterator_t.insert_after.
*/
static status_t insert_after(private_iterator_t * iterator, void *item)
static void insert_after(private_iterator_t * iterator, void *item)
{
if (iterator->current == NULL)
{
return (iterator->list->public.insert_first(&(iterator->list->public),item));
iterator->list->public.insert_first(&(iterator->list->public),item);
}
linked_list_element_t *element =(linked_list_element_t *) linked_list_element_create(item);
if (element == NULL)
{
return OUT_OF_RES;
}
if (iterator->current->next == NULL)
{
if (iterator->list->last != iterator->current)
{
element->destroy(element);
return FAILED;
}
iterator->current->next = element;
element->previous = iterator->current;
iterator->list->last = element;
@@ -350,18 +317,15 @@ static status_t insert_after(private_iterator_t * iterator, void *item)
iterator->current->next = element;
element->previous = iterator->current;
}
iterator->list->count++;
return SUCCESS;
}
/**
* Implementation of iterator_t.destroy.
*/
static status_t iterator_destroy(private_iterator_t *this)
static void iterator_destroy(private_iterator_t *this)
{
allocator_free(this);
return SUCCESS;
}
/**
@@ -376,17 +340,12 @@ static int get_count(private_linked_list_t *this)
/**
* Implementation of linked_list_t.insert_first.
*/
static status_t insert_first(private_linked_list_t *this, void *item)
static void insert_first(private_linked_list_t *this, void *item)
{
linked_list_element_t *element;
element =(linked_list_element_t *) linked_list_element_create(item);
if (element == NULL)
{
return OUT_OF_RES;
}
if (this->count == 0)
{
/* first entry in list */
@@ -397,12 +356,6 @@ static status_t insert_first(private_linked_list_t *this, void *item)
}
else
{
if ((this->first == NULL) || (this->last == NULL))
{
/* should never happen */
element->destroy(element);
return FAILED;
}
linked_list_element_t *old_first_element = this->first;
element->next = old_first_element;
element->previous = NULL;
@@ -411,8 +364,6 @@ static status_t insert_first(private_linked_list_t *this, void *item)
}
this->count++;
return SUCCESS;
}
/**
@@ -437,7 +388,9 @@ static status_t remove_first(private_linked_list_t *this, void **item)
this->count--;
return (element->destroy(element));
element->destroy(element);
return SUCCESS;
}
/**
@@ -458,15 +411,10 @@ static status_t get_first(private_linked_list_t *this, void **item)
/**
* Implementation of linked_list_t.insert_last.
*/
static status_t insert_last(private_linked_list_t *this, void *item)
static void insert_last(private_linked_list_t *this, void *item)
{
linked_list_element_t *element = (linked_list_element_t *) linked_list_element_create(item);
if (element == NULL)
{
return OUT_OF_RES;
}
if (this->count == 0)
{
/* first entry in list */
@@ -474,14 +422,10 @@ static status_t insert_last(private_linked_list_t *this, void *item)
this->last = element;
element->previous = NULL;
element->next = NULL;
}else
}
else
{
if ((this->first == NULL) || (this->last == NULL))
{
/* should never happen */
element->destroy(element);
return FAILED;
}
linked_list_element_t *old_last_element = this->last;
element->previous = old_last_element;
element->next = NULL;
@@ -490,8 +434,6 @@ static status_t insert_last(private_linked_list_t *this, void *item)
}
this->count++;
return SUCCESS;
}
/**
@@ -516,7 +458,9 @@ static status_t remove_last(private_linked_list_t *this, void **item)
this->count--;
return (element->destroy(element));
element->destroy(element);
return SUCCESS;
}
/**
@@ -537,48 +481,39 @@ static status_t get_last(private_linked_list_t *this, void **item)
/**
* Implementation of linked_list_t.create_iterator.
*/
static status_t create_iterator (private_linked_list_t *linked_list, iterator_t **iterator,bool forward)
static void create_iterator (private_linked_list_t *linked_list, iterator_t **iterator,bool forward)
{
private_iterator_t *this = allocator_alloc_thing(private_iterator_t);
if (this == NULL)
{
return OUT_OF_RES;
}
this->public.has_next = (bool (*) (iterator_t *this)) iterator_has_next;
this->public.current = (status_t (*) (iterator_t *this, void **value)) iterator_current;
this->public.insert_before = (status_t (*) (iterator_t *this, void *item)) insert_before;
this->public.insert_after = (status_t (*) (iterator_t *this, void *item)) insert_after;
this->public.insert_before = (void (*) (iterator_t *this, void *item)) insert_before;
this->public.insert_after = (void (*) (iterator_t *this, void *item)) insert_after;
this->public.remove = (status_t (*) (iterator_t *this)) remove;
this->public.reset = (status_t (*) (iterator_t *this)) iterator_reset;
this->public.destroy = (status_t (*) (iterator_t *this)) iterator_destroy;
this->public.reset = (void (*) (iterator_t *this)) iterator_reset;
this->public.destroy = (void (*) (iterator_t *this)) iterator_destroy;
this->forward = forward;
this->current = NULL;
this->list = linked_list;
*iterator = &(this->public);
return (SUCCESS);
}
/**
* Implementation of linked_list_t.destroy.
*/
static status_t linked_list_destroy(private_linked_list_t *this)
static void linked_list_destroy(private_linked_list_t *this)
{
void * value;
/* Remove all list items before destroying list */
while (this->public.remove_first(&(this->public),&value) != NOT_FOUND)
{
/* values are not destroyed so memory leaks are possible
* if list is not empty when deleting */
}
allocator_free(this);
return SUCCESS;
}
/*
@@ -589,14 +524,14 @@ linked_list_t *linked_list_create()
private_linked_list_t *this = allocator_alloc_thing(private_linked_list_t);
this->public.get_count = (int (*) (linked_list_t *linked_list)) get_count;
this->public.create_iterator = (status_t (*) (linked_list_t *linked_list, iterator_t **iterator,bool forward)) create_iterator;
this->public.create_iterator = (void (*) (linked_list_t *linked_list, iterator_t **iterator,bool forward)) create_iterator;
this->public.get_first = (status_t (*) (linked_list_t *linked_list, void **item)) get_first;
this->public.get_last = (status_t (*) (linked_list_t *linked_list, void **item)) get_last;
this->public.insert_first = (status_t (*) (linked_list_t *linked_list, void *item)) insert_first;
this->public.insert_last = (status_t (*) (linked_list_t *linked_list, void *item)) insert_last;
this->public.insert_first = (void (*) (linked_list_t *linked_list, void *item)) insert_first;
this->public.insert_last = (void (*) (linked_list_t *linked_list, void *item)) insert_last;
this->public.remove_first = (status_t (*) (linked_list_t *linked_list, void **item)) remove_first;
this->public.remove_last = (status_t (*) (linked_list_t *linked_list, void **item)) remove_last;
this->public.destroy = (status_t (*) (linked_list_t *linked_list)) linked_list_destroy;
this->public.destroy = (void (*) (linked_list_t *linked_list)) linked_list_destroy;
this->count = 0;
this->first = NULL;
Source/charon/utils/linked_list.h
+10 -19
View File
@@ -43,8 +43,8 @@ struct linked_list_t {
/**
* @brief Gets the count of items in the list.
*
* @param linked_list calling object
* @return number of items in list
* @param linked_list calling object
* @return number of items in list
*/
int (*get_count) (linked_list_t *linked_list);
@@ -53,26 +53,19 @@ struct linked_list_t {
*
* @warning Created iterator has to get destroyed by the caller.
*
* @param linked_list calling object
* @param linked_list calling object
* @param[out] iterator place where the iterator is written
* @param[in] forward iterator direction (TRUE: front to end)
* @return
* - SUCCESS
* - OUT_OF_RES
* @param[in] forward iterator direction (TRUE: front to end)
*/
status_t (*create_iterator) (linked_list_t *linked_list, iterator_t **iterator,bool forward);
void (*create_iterator) (linked_list_t *linked_list, iterator_t **iterator, bool forward);
/**
* @brief Inserts a new item at the beginning of the list.
*
* @param linked_list calling object
* @param[in] item value to insert in list
* @return
* - SUCCESS
* - FAILED if internal list is corrupted.
* - OUT_OF_RES
*/
status_t (*insert_first) (linked_list_t *linked_list, void *item);
void (*insert_first) (linked_list_t *linked_list, void *item);
/**
* @brief Removes the first item in the list and returns its value.
@@ -101,12 +94,8 @@ struct linked_list_t {
*
* @param linked_list calling object
* @param[in] item value to insert into list
* @return
* - SUCCESS
* - FAILED if internal list is corrupted.
* - OUT_OF_RES
*/
status_t (*insert_last) (linked_list_t *linked_list, void *item);
void (*insert_last) (linked_list_t *linked_list, void *item);
/**
* @brief Removes the last item in the list and returns its value.
@@ -142,12 +131,14 @@ struct linked_list_t {
* @return
* - SUCCESS
*/
status_t (*destroy) (linked_list_t *linked_list);
void (*destroy) (linked_list_t *linked_list);
};
/**
* @brief Creates an empty linked list object.
*
* @return the created linked list.
*
* @ingroup utils
*/
linked_list_t *linked_list_create();
Source/charon/utils/logger.c
+13 -32
View File
@@ -41,7 +41,7 @@
typedef struct private_logger_t private_logger_t;
/**
* @brief The logger object.
* @brief The logger object's private data.
*/
struct private_logger_t {
/**
@@ -119,7 +119,6 @@ static void prepend_prefix(private_logger_t *this, logger_level_t loglevel, char
log_details = '0';
}
if (this->log_pid)
{
snprintf(buffer, MAX_LOG, "[%c%c] [%s] @%d %s", log_type, log_details, this->name, getpid(), string);
@@ -128,7 +127,6 @@ static void prepend_prefix(private_logger_t *this, logger_level_t loglevel, char
{
snprintf(buffer, MAX_LOG, "[%c%c] [%s] %s", log_type, log_details, this->name, string);
}
}
/**
@@ -136,7 +134,7 @@ static void prepend_prefix(private_logger_t *this, logger_level_t loglevel, char
*
* Yes, logg is wrong written :-).
*/
static status_t logg(private_logger_t *this, logger_level_t loglevel, char *format, ...)
static void logg(private_logger_t *this, logger_level_t loglevel, char *format, ...)
{
if ((this->level & loglevel) == loglevel)
{
@@ -163,13 +161,12 @@ static status_t logg(private_logger_t *this, logger_level_t loglevel, char *form
}
}
return SUCCESS;
}
/**
* Implementation of logger_t.log_bytes.
*/
static status_t log_bytes(private_logger_t *this, logger_level_t loglevel, char *label, char *bytes, size_t len)
static void log_bytes(private_logger_t *this, logger_level_t loglevel, char *label, char *bytes, size_t len)
{
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
@@ -256,48 +253,42 @@ static status_t log_bytes(private_logger_t *this, logger_level_t loglevel, char
}
}
}
pthread_mutex_unlock(&mutex);
return SUCCESS;
}
/**
* Implementation of logger_t.log_chunk.
*/
static status_t log_chunk(logger_t *this, logger_level_t loglevel, char *label, chunk_t *chunk)
static void log_chunk(logger_t *this, logger_level_t loglevel, char *label, chunk_t *chunk)
{
this->log_bytes(this, loglevel, label, chunk->ptr, chunk->len);
return SUCCESS;
}
/**
* Implementation of logger_t.enable_level.
*/
static status_t enable_level(private_logger_t *this, logger_level_t log_level)
static void enable_level(private_logger_t *this, logger_level_t log_level)
{
this->level |= log_level;
return SUCCESS;
}
/**
* Implementation of logger_t.disable_level.
*/
static status_t disable_level(private_logger_t *this, logger_level_t log_level)
static void disable_level(private_logger_t *this, logger_level_t log_level)
{
this->level &= ~log_level;
return SUCCESS;
}
/**
* Implementation of logger_t.destroy.
*/
static status_t destroy(private_logger_t *this)
static void destroy(private_logger_t *this)
{
allocator_free(this->name);
allocator_free(this);
return SUCCESS;
}
/*
@@ -306,23 +297,18 @@ static status_t destroy(private_logger_t *this)
logger_t *logger_create(char *logger_name, logger_level_t log_level, bool log_pid, FILE * output)
{
private_logger_t *this = allocator_alloc_thing(private_logger_t);
if (this == NULL)
{
return NULL;
}
if (logger_name == NULL)
{
logger_name = "";
}
this->public.log = (status_t(*)(logger_t*,logger_level_t,char*,...))logg;
this->public.log_bytes = (status_t(*)(logger_t*, logger_level_t, char*,char*,size_t))log_bytes;
this->public.log = (void(*)(logger_t*,logger_level_t,char*,...))logg;
this->public.log_bytes = (void(*)(logger_t*, logger_level_t, char*,char*,size_t))log_bytes;
this->public.log_chunk = log_chunk;
this->public.enable_level = (status_t(*)(logger_t*,logger_level_t))enable_level;
this->public.disable_level = (status_t(*)(logger_t*,logger_level_t))disable_level;
this->public.destroy = (status_t(*)(logger_t*))destroy;
this->public.enable_level = (void(*)(logger_t*,logger_level_t))enable_level;
this->public.disable_level = (void(*)(logger_t*,logger_level_t))disable_level;
this->public.destroy = (void(*)(logger_t*))destroy;
this->prepend_prefix = prepend_prefix;
@@ -330,14 +316,9 @@ logger_t *logger_create(char *logger_name, logger_level_t log_level, bool log_pi
this->level = log_level;
this->log_pid = log_pid;
this->name = allocator_alloc(strlen(logger_name) + 1);
if (this->name == NULL)
{
allocator_free(this);
return NULL;
}
strcpy(this->name,logger_name);
this->output = output;
if (output == NULL)
{
Source/charon/utils/logger.h
+7 -15
View File
@@ -99,9 +99,8 @@ struct logger_t {
* @param loglevel or'ed set of loglevels
* @param format printf like format string
* @param ... printf like parameters
* @return SUCCESS in any case
*/
status_t (*log) (logger_t *this, logger_level_t log_level, char *format, ...);
void (*log) (logger_t *this, logger_level_t log_level, char *format, ...);
/**
* @brief Log some bytes, useful for debugging.
@@ -114,9 +113,8 @@ struct logger_t {
* @param label a labeling name, logged with the bytes
* @param bytes pointer to the bytes to dump
* @param len number of bytes to dump
* @return SUCCESS in any case
*/
status_t (*log_bytes) (logger_t *this, logger_level_t loglevel, char *label, char *bytes, size_t len);
void (*log_bytes) (logger_t *this, logger_level_t loglevel, char *label, char *bytes, size_t len);
/**
* @brief Log a chunk, useful for debugging.
@@ -128,35 +126,31 @@ struct logger_t {
* @param loglevel or'ed set of loglevels
* @param label a labeling name, logged with the bytes
* @param chunk pointer to a chunk to log
* @return SUCCESS in any case
*/
status_t (*log_chunk) (logger_t *this, logger_level_t loglevel, char *label, chunk_t *chunk);
void (*log_chunk) (logger_t *this, logger_level_t loglevel, char *label, chunk_t *chunk);
/**
* @brief Enables a loglevel for the current logger_t object.
*
* @param this logger_t object
* @param log_level loglevel to enable
* @return SUCCESS in any case
*/
status_t (*enable_level) (logger_t *this, logger_level_t log_level);
void (*enable_level) (logger_t *this, logger_level_t log_level);
/**
* @brief Disables a loglevel for the current logger_t object.
*
* @param this logger_t object
* @param log_level loglevel to enable
* @return UCCESS in any case
*/
status_t (*disable_level) (logger_t *this, logger_level_t log_level);
void (*disable_level) (logger_t *this, logger_level_t log_level);
/**
* @brief Destroys a logger_t object.
*
* @param this logger_t object
* @return SUCCESS in any case
*/
status_t (*destroy) (logger_t *this);
void (*destroy) (logger_t *this);
};
/**
@@ -166,9 +160,7 @@ struct logger_t {
* @param log_level or'ed set of log_levels to assign to the new logger_t object
* @param log_pid TRUE if thread id should also be logged
* @param output FILE * if log has to go on a file output, NULL for syslog
* @return
* - logger_t object
* - NULL if out of ressources
* @return logger_t object
*
* @ingroup utils
*/
Source/charon/utils/logger_manager.c
+31 -130
View File
@@ -89,11 +89,8 @@ struct private_logger_manager_t {
* @param context context to set level
* @param logger_level logger_level to set
* @param enable enable specific level or disable it
* @return
* - SUCCESS
* - OUT_OF_RES
*/
status_t (*set_logger_level) (private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level,bool enable);
void (*set_logger_level) (private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level,bool enable);
};
@@ -184,32 +181,13 @@ static logger_t *create_logger(private_logger_manager_t *this, logger_context_t
logger = logger_create(context_name,logger_level,log_thread_ids,output);
}
if (logger == NULL)
{
pthread_mutex_unlock(&(this->mutex));
return NULL;
}
entry = allocator_alloc_thing(loggers_entry_t);
if (entry == NULL)
{
logger->destroy(logger);
pthread_mutex_unlock(&(this->mutex));
return NULL;
}
entry->context = context;
entry->logger = logger;
if (this->loggers->insert_last(this->loggers,entry) != SUCCESS)
{
allocator_free(entry);
logger->destroy(logger);
pthread_mutex_unlock(&(this->mutex));
return NULL;
}
this->loggers->insert_last(this->loggers,entry);
pthread_mutex_unlock(&(this->mutex));
return logger;
@@ -227,28 +205,18 @@ static logger_level_t get_logger_level (private_logger_manager_t *this, logger_c
pthread_mutex_lock(&(this->mutex));
if (this->logger_levels->create_iterator(this->logger_levels,&iterator,TRUE) != SUCCESS)
{
pthread_mutex_unlock(&(this->mutex));
return logger_level;
}
this->logger_levels->create_iterator(this->logger_levels, &iterator,TRUE);
/* check for existing logger_level entry */
while (iterator->has_next(iterator))
{
logger_levels_entry_t * entry;
if (iterator->current(iterator,(void **)&entry) != SUCCESS)
{
break;
}
iterator->current(iterator,(void **)&entry);
if (entry->context == context)
{
logger_level = entry->level;
break;
}
}
iterator->destroy(iterator);
pthread_mutex_unlock(&(this->mutex));
@@ -258,71 +226,45 @@ static logger_level_t get_logger_level (private_logger_manager_t *this, logger_c
/**
* Implementation of logger_manager_t.destroy_logger.
*/
static status_t destroy_logger (private_logger_manager_t *this,logger_t *logger)
static void destroy_logger(private_logger_manager_t *this,logger_t *logger)
{
iterator_t *iterator;
status_t status = NOT_FOUND;
pthread_mutex_lock(&(this->mutex));
if (this->loggers->create_iterator(this->loggers,&iterator,TRUE) != SUCCESS)
{
pthread_mutex_unlock(&(this->mutex));
return OUT_OF_RES;
}
this->loggers->create_iterator(this->loggers,&iterator,TRUE);
while (iterator->has_next(iterator))
{
loggers_entry_t * entry;
status = iterator->current(iterator,(void **)&entry);
if (status != SUCCESS)
{
break;
}
status = NOT_FOUND;
iterator->current(iterator,(void **)&entry);
if (entry->logger == logger)
{
iterator->remove(iterator);
allocator_free(entry);
logger->destroy(logger);
status = SUCCESS;
break;
}
}
iterator->destroy(iterator);
pthread_mutex_unlock(&(this->mutex));
return status;
}
/**
* Implementation of private_logger_manager_t.set_logger_level.
*/
static status_t set_logger_level (private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level,bool enable)
static void set_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level,bool enable)
{
iterator_t *iterator;
status_t status;
bool found = FALSE;
pthread_mutex_lock(&(this->mutex));
if (this->logger_levels->create_iterator(this->logger_levels,&iterator,TRUE) != SUCCESS)
{
pthread_mutex_unlock(&(this->mutex));
return OUT_OF_RES;
}
this->logger_levels->create_iterator(this->logger_levels,&iterator,TRUE);
status = NOT_FOUND;
/* find existing logger_level entry */
while (iterator->has_next(iterator))
{
logger_levels_entry_t * entry;
status = iterator->current(iterator,(void **)&entry);
if (status != SUCCESS)
{
iterator->destroy(iterator);
pthread_mutex_unlock(&(this->mutex));
return status;
}
status = NOT_FOUND;
iterator->current(iterator,(void **)&entry);
if (entry->context == context)
{
if (enable)
@@ -333,74 +275,51 @@ static status_t set_logger_level (private_logger_manager_t *this, logger_context
{
entry->level &= ~logger_level;
}
status = SUCCESS;
found = TRUE;
break;
}
}
iterator->destroy(iterator);
if (status == NOT_FOUND)
if (!found)
{
/* logger_levels entry not existing for current context */
logger_levels_entry_t *entry = allocator_alloc_thing(logger_levels_entry_t);
if (entry == NULL)
{
pthread_mutex_unlock(&(this->mutex));
return OUT_OF_RES;
}
entry->context = context;
entry->level = (enable) ? logger_level : (this->default_log_level & (~logger_level));
status = this->logger_levels->insert_last(this->logger_levels,entry);
if (status != SUCCESS)
{
allocator_free(entry);
pthread_mutex_unlock(&(this->mutex));
return status;
}
this->logger_levels->insert_last(this->logger_levels,entry);
}
if (this->loggers->create_iterator(this->loggers,&iterator,TRUE) != SUCCESS)
{
pthread_mutex_unlock(&(this->mutex));
return OUT_OF_RES;
}
this->loggers->create_iterator(this->loggers,&iterator,TRUE);
while (iterator->has_next(iterator))
{
loggers_entry_t * entry;
status = iterator->current(iterator,(void **)&entry);
if (status != SUCCESS)
{
iterator->destroy(iterator);
pthread_mutex_unlock(&(this->mutex));
return status;
}
iterator->current(iterator,(void **)&entry);
if (entry->context == context)
{
if (enable)
{
status = entry->logger->enable_level(entry->logger,logger_level);
entry->logger->enable_level(entry->logger,logger_level);
}
else
{
status = entry->logger->disable_level(entry->logger,logger_level);
entry->logger->disable_level(entry->logger,logger_level);
}
}
}
iterator->destroy(iterator);
pthread_mutex_unlock(&(this->mutex));
return SUCCESS;
}
/**
* Implementation of logger_manager_t.enable_logger_level.
*/
static status_t enable_logger_level (private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
static void enable_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
{
return set_logger_level(this,context,logger_level,TRUE);
}
@@ -408,7 +327,7 @@ static status_t enable_logger_level (private_logger_manager_t *this, logger_cont
/**
* Implementation of logger_manager_t.disable_logger_level.
*/
static status_t disable_logger_level (private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
static void disable_logger_level(private_logger_manager_t *this, logger_context_t context,logger_level_t logger_level)
{
return set_logger_level(this,context,logger_level,FALSE);
}
@@ -416,7 +335,7 @@ static status_t disable_logger_level (private_logger_manager_t *this, logger_con
/**
* Implementation of logger_manager_t.destroy.
*/
static status_t destroy(private_logger_manager_t *this)
static void destroy(private_logger_manager_t *this)
{
while (this->loggers->get_count(this->loggers) > 0)
@@ -447,7 +366,6 @@ static status_t destroy(private_logger_manager_t *this)
pthread_mutex_destroy(&(this->mutex));
allocator_free(this);
return SUCCESS;
}
/*
@@ -456,35 +374,18 @@ static status_t destroy(private_logger_manager_t *this)
logger_manager_t *logger_manager_create(logger_level_t default_log_level)
{
private_logger_manager_t *this = allocator_alloc_thing(private_logger_manager_t);
if (this == NULL)
{
return NULL;
}
this->public.create_logger = (logger_t *(*)(logger_manager_t*,logger_context_t context, char *))create_logger;
this->public.destroy_logger = (status_t(*)(logger_manager_t*,logger_t *logger))destroy_logger;
this->public.destroy = (status_t(*)(logger_manager_t*))destroy;
this->public.destroy_logger = (void(*)(logger_manager_t*,logger_t *logger))destroy_logger;
this->public.destroy = (void(*)(logger_manager_t*))destroy;
this->public.get_logger_level = (logger_level_t (*)(logger_manager_t *, logger_context_t)) get_logger_level;
this->public.enable_logger_level = (status_t (*)(logger_manager_t *, logger_context_t,logger_level_t)) enable_logger_level;
this->public.disable_logger_level = (status_t (*)(logger_manager_t *, logger_context_t,logger_level_t)) disable_logger_level;
this->set_logger_level = (status_t (*)(private_logger_manager_t *, logger_context_t,logger_level_t,bool)) set_logger_level;
this->public.enable_logger_level = (void (*)(logger_manager_t *, logger_context_t,logger_level_t)) enable_logger_level;
this->public.disable_logger_level = (void (*)(logger_manager_t *, logger_context_t,logger_level_t)) disable_logger_level;
this->set_logger_level = (void (*)(private_logger_manager_t *, logger_context_t,logger_level_t,bool)) set_logger_level;
/* private variables */
this->loggers = linked_list_create();
if (this->loggers == NULL)
{
allocator_free(this);
return NULL;
}
this->logger_levels = linked_list_create();
if (this->logger_levels == NULL)
{
this->loggers->destroy(this->loggers);
allocator_free(this);
return NULL;
}
this->default_log_level = default_log_level;
pthread_mutex_init(&(this->mutex), NULL);
Source/charon/utils/logger_manager.h
+7 -22
View File
@@ -73,9 +73,7 @@ struct logger_manager_t {
* @param[out] logger pointer to a a place where the new logger is stored
* @param name name for the new logger. Context name is already included
* and has not to be specified (so NULL is allowed)
* @return
* - logger_t object
* - NULL if out of ressources
* @return logger_t object
*/
logger_t *(*create_logger) (logger_manager_t *this, logger_context_t context, char *name);
@@ -88,12 +86,9 @@ struct logger_manager_t {
* destroy function.
*
* @param this logger_manager_t object
* @param logger pointer to the logger which has to be destroyed
* @return - SUCCESS
* - OUT_OF_RES (when searching the specific logger_t object)
* - NOT_FOUND
* @param logger pointer to the logger which has to be destroyed
*/
status_t (*destroy_logger) (logger_manager_t *this,logger_t *logger);
void (*destroy_logger) (logger_manager_t *this,logger_t *logger);
/**
* Returns the set logger_level of a specific context or 0.
@@ -110,11 +105,8 @@ struct logger_manager_t {
* @param this calling object
* @param context context to set level
* @param logger_level logger_level to eanble
* @return
* - SUCCESS
* - OUT_OF_RES
*/
status_t (*enable_logger_level) (logger_manager_t *this, logger_context_t context,logger_level_t logger_level);
void (*enable_logger_level) (logger_manager_t *this, logger_context_t context,logger_level_t logger_level);
/**
@@ -123,11 +115,8 @@ struct logger_manager_t {
* @param this calling object
* @param context context to set level
* @param logger_level logger_level to disable
* @return
* - SUCCESS
* - OUT_OF_RES
*/
status_t (*disable_logger_level) (logger_manager_t *this, logger_context_t context,logger_level_t logger_level);
void (*disable_logger_level) (logger_manager_t *this, logger_context_t context,logger_level_t logger_level);
/**
@@ -136,19 +125,15 @@ struct logger_manager_t {
* All remaining managed logger_t objects are also destroyed.
*
* @param this logger_manager_t object
* @return
* - SUCCESS in any case
*/
status_t (*destroy) (logger_manager_t *this);
void (*destroy) (logger_manager_t *this);
};
/**
* @brief Constructor to create a logger_manager_t object.
*
* @param default_log_level default log level for a context
* @return
* - logger_manager_t object
* - NULL if out of ressources
* @return logger_manager_t object
*
* @ingroup utils
*/
Source/charon/utils/randomizer.c
+3 -24
View File
@@ -155,13 +155,11 @@ static status_t allocate_pseudo_random_bytes(private_randomizer_t *this, size_t
/**
* Implementation of randomizer_t.destroy.
*/
static status_t destroy(private_randomizer_t *this)
static void destroy(private_randomizer_t *this)
{
allocator_free(this->random_dev_name);
allocator_free(this->pseudo_random_dev_name);
allocator_free(this);
return SUCCESS;
}
/*
@@ -178,41 +176,22 @@ randomizer_t *randomizer_create(void)
randomizer_t *randomizer_create_on_devices(char * random_dev_name,char * prandom_dev_name)
{
private_randomizer_t *this = allocator_alloc_thing(private_randomizer_t);
if (this == NULL)
{
return NULL;
}
if ((random_dev_name == NULL) || (prandom_dev_name == NULL))
{
return NULL;
}
/* public functions */
this->public.get_random_bytes = (status_t (*) (randomizer_t *,size_t, u_int8_t *)) get_random_bytes;
this->public.allocate_random_bytes = (status_t (*) (randomizer_t *,size_t, chunk_t *)) allocate_random_bytes;
this->public.get_pseudo_random_bytes = (status_t (*) (randomizer_t *,size_t, u_int8_t *)) get_pseudo_random_bytes;
this->public.allocate_pseudo_random_bytes = (status_t (*) (randomizer_t *,size_t, chunk_t *)) allocate_pseudo_random_bytes;
this->public.destroy = (status_t (*) (randomizer_t *))destroy;
this->public.destroy = (void (*) (randomizer_t *))destroy;
/* private functions */
this->get_bytes_from_device = get_bytes_from_device;
/* private fields */
this->random_dev_name = allocator_alloc(strlen(random_dev_name) + 1);
if (this->random_dev_name == NULL)
{
allocator_free(this);
return NULL;
}
strcpy(this->random_dev_name,random_dev_name);
this->pseudo_random_dev_name = allocator_alloc(strlen(prandom_dev_name) + 1);
if (this->pseudo_random_dev_name == NULL)
{
allocator_free(this->random_dev_name);
allocator_free(this);
return NULL;
}
strcpy(this->pseudo_random_dev_name,prandom_dev_name);
return &(this->public);
Source/charon/utils/randomizer.h
+3 -6
View File
@@ -54,10 +54,9 @@ struct randomizer_t {
*
* @param this calling randomizer_t object
* @param bytes number of bytes to allocate
* @param[out] chunk chunk which will hold the allocated random bytes
* @param[out] chunk chunk which will hold the allocated random bytes
* @return
* - SUCCESS
* - OUT_OF_RES
* - FAILED if random device could not be opened
*/
status_t (*allocate_random_bytes) (randomizer_t *this, size_t bytes, chunk_t *chunk);
@@ -83,7 +82,6 @@ struct randomizer_t {
* @param[out] chunk chunk which will hold the allocated random bytes
* @return
* - SUCCESS
* - OUT_OF_RES
* - FAILED if random device could not be opened
*/
status_t (*allocate_pseudo_random_bytes) (randomizer_t *this, size_t bytes, chunk_t *chunk);
@@ -92,9 +90,8 @@ struct randomizer_t {
* @brief Destroys a randomizer_t object.
*
* @param this randomizer_t object to destroy
* @return SUCCESS in any case
*/
status_t (*destroy) (randomizer_t *this);
void (*destroy) (randomizer_t *this);
};
/**
@@ -115,7 +112,7 @@ randomizer_t *randomizer_create();
* @param prandom_dev_name device name for pseudo random values, etc /dev/urandom
* @return
* - created randomizer_t
* - NULL if out of ressources
* - NULL if failed
*
* @ingroup utils
*/
Source/charon/utils/tester.c
+3 -5
View File
@@ -93,7 +93,7 @@ struct private_tester_t {
/**
* Implementation of tester_t.perform_tests.
*/
static status_t perform_tests(tester_t *tester,test_t **tests)
static void perform_tests(tester_t *tester,test_t **tests)
{
private_tester_t *this =(private_tester_t*) tester;
int current_test = 0;
@@ -110,13 +110,12 @@ static status_t perform_tests(tester_t *tester,test_t **tests)
fprintf(this->output,"=====================================================================\n");
fprintf(this->output,"End testing. %d of %d tests succeeded\n",this->tests_count - this->failed_tests_count,this->tests_count);
fprintf(this->output,"=====================================================================\n");
return SUCCESS;
}
/**
* Implementation of tester_t.perform_test.
*/
static status_t perform_test(tester_t *tester, test_t *test)
static void perform_test(tester_t *tester, test_t *test)
{
test_t *tests[] = {test, NULL};
return (perform_tests(tester,tests));
@@ -214,12 +213,11 @@ static void assert_false(tester_t *tester, bool to_be_false,char * assert_name)
/**
* Implementation of tester_t.destroy.
*/
static status_t destroy(tester_t *tester)
static void destroy(tester_t *tester)
{
private_tester_t *this = (private_tester_t*) tester;
pthread_mutex_destroy(&(this->mutex));
allocator_free(this);
return SUCCESS;
}
/*
Source/charon/utils/tester.h
+4 -9
View File
@@ -63,18 +63,16 @@ struct tester_t {
* @param tester tester_t object
* @param tests pointer to an array of test_t-pointers.
* The last item has to be NULL.
* @return SUCCESS in any case
*/
status_t (*perform_tests) (tester_t *tester,test_t **tests);
void (*perform_tests) (tester_t *tester,test_t **tests);
/**
* @brief Run a specific test case.
*
* @param this tester_t object
* @param test pointer to a test_t object which will be performed
* @return SUCCESS in any case
*/
status_t (*perform_test) (tester_t *tester, test_t *test);
void (*perform_test) (tester_t *tester, test_t *test);
/**
* Is called in a testcase to check a specific situation for TRUE.
@@ -106,9 +104,8 @@ struct tester_t {
* @brief Destroys a tester_t object
*
* @param tester tester_t object
* @return SUCCESS in any case
*/
status_t (*destroy) (tester_t *tester);
void (*destroy) (tester_t *tester);
};
/**
@@ -118,9 +115,7 @@ struct tester_t {
* @param display_succeeded_asserts has to be TRUE, if all asserts should be displayed,
* FALSE otherwise
*
* @return
* - tester_t object
* - NULL if out of ressources
* @return - tester_t object
*
* @ingroup utils
*/