list.c File Reference

#include "list.h"
#include <stdlib.h>
#include <string.h>
#include "../common/insecure_memzero.h"

Include dependency graph for list.c:

Go to the source code of this file.

Functions
void	list_create (List *list, int item_size, FreeItemFn free_item_fn)
void	list_destroy (List *list)
bool	list_prepend (List *list, void *item)
bool	list_append (List *list, void *item)
ListItem *	list_get (List *list, void *data, CompareItemFn compare_item_fn)
void	list_delete (List *list, ListItem *item)
void	list_iterate (List *list, IteratorFn iterator_fn)

Function Documentation

list_append()

bool list_append	(	List *	list,
		void *	item )

Definition at line 78 of file list.c.

                                         {
 
  ListItem *node = calloc(1, sizeof(ListItem));
  if (node == NULL) {
    return false;
  }
 
  node->data = calloc(1, list->item_size);
  if (node->data == NULL) {
    free(node);
    return false;
  }
 
  memcpy(node->data, item, list->item_size);
 
  if (list->length == 0) {
    list->head = node;
    list->tail = node;
  } else {
    list->tail->next = node;
    list->tail = node;
  }
 
  list->length++;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

list_create()

void list_create	(	List *	list,
		int	item_size,
		FreeItemFn	free_item_fn )

Definition at line 24 of file list.c.

                                                                     {
 
  list->length = 0;
  list->item_size = item_size;
  list->head = NULL;
  list->tail = NULL;
  list->free_item_fn = free_item_fn;
}

Here is the caller graph for this function:

list_delete()

void list_delete	(	List *	list,
		ListItem *	item )

Definition at line 117 of file list.c.

                                             {
 
  if (item == NULL) {
 
    return;
  }
 
  if (item == list->head) {
    if (list->head == list->tail) {
      list->head = NULL;
      list->tail = NULL;
    } else {
      list->head = list->head->next;
    }
 
    if (list->free_item_fn) {
      list->free_item_fn(item->data);
    }
    insecure_memzero(item->data, list->item_size);
    free(item->data);
    free(item);
  } else if (item == list->tail) {
    for (ListItem *i = list->head; i != NULL; i = i->next) {
      if (i->next == list->tail) {
        list->tail = i;
        i->next = NULL;
 
        if (list->free_item_fn) {
          list->free_item_fn(item->data);
        }
        insecure_memzero(item->data, list->item_size);
        free(item->data);
        free(item);
      }
    }
  } else {
    if (list->free_item_fn) {
      list->free_item_fn(item->data);
    }
 
    ListItem *tmp = item->next;
 
    insecure_memzero(item->data, list->item_size);
    free(item->data);
 
    item->data = item->next->data;
    item->next = item->next->next;
 
    if (tmp == list->tail) {
      list->tail = item;
    }
 
    free(tmp);
  }
 
  list->length--;
}

Here is the caller graph for this function:

list_destroy()

void list_destroy

(

List *

list

)

Definition at line 33 of file list.c.

                              {
 
  ListItem *current;
 
  while (list->head != NULL) {
    current = list->head;
    list->head = current->next;
 
    if (list->free_item_fn) {
      list->free_item_fn(current->data);
    }
 
    insecure_memzero(current->data, list->item_size);
    free(current->data);
    free(current);
  }
}

Here is the caller graph for this function:

list_get()

ListItem * list_get	(	List *	list,
		void *	data,
		CompareItemFn	compare_item_fn )

Definition at line 105 of file list.c.

                                                                          {
 
  for (ListItem *item = list->head; item != NULL; item = item->next) {
    if (compare_item_fn(data, item->data) == true) {
 
      return item;
    }
  }
 
  return NULL;
}

Here is the caller graph for this function:

list_iterate()

void list_iterate	(	List *	list,
		IteratorFn	iterator_fn )

Definition at line 175 of file list.c.

                                                      {
 
  for (ListItem *item = list->head; item != NULL; item = item->next) {
    iterator_fn(item->data);
  }
}

Here is the caller graph for this function:

list_prepend()

bool list_prepend	(	List *	list,
		void *	item )

Definition at line 51 of file list.c.

                                          {
 
  ListItem *node = calloc(1, sizeof(ListItem));
  if (node == NULL) {
    return false;
  }
 
  node->data = calloc(1, list->item_size);
 
  if (node->data == NULL) {
    free(node);
    return false;
  }
 
  memcpy(node->data, item, list->item_size);
 
  node->next = list->head;
  list->head = node;
 
  if (list->tail == NULL) {
    list->tail = list->head;
  }
 
  list->length++;
  return true;
}

Here is the call graph for this function: