/src/selinux/checkpolicy/queue.c

Source (jump to first uncovered line)

/* Author : Stephen Smalley, <stephen.smalley.work@gmail.com> */

/* FLASK */

/*
 * Implementation of the double-ended queue type.
 */

#include <stdlib.h>
#include "queue.h"

queue_t queue_create(void)
{
  queue_t q;

  q = (queue_t) malloc(sizeof(struct queue_info));
  if (q == NULL)
    return NULL;

  q->head = q->tail = NULL;

  return q;
}

int queue_insert(queue_t q, queue_element_t e)
{
  queue_node_ptr_t newnode;

  if (!q)
    return -1;

  newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
  if (newnode == NULL)
    return -1;

  newnode->element = e;
  newnode->next = NULL;

  if (q->head == NULL) {
    q->head = q->tail = newnode;
  } else {
    q->tail->next = newnode;
    q->tail = newnode;
  }

  return 0;
}

int queue_push(queue_t q, queue_element_t e)
{
  queue_node_ptr_t newnode;

  if (!q)
    return -1;

  newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
  if (newnode == NULL)
    return -1;

  newnode->element = e;
  newnode->next = NULL;

  if (q->head == NULL) {
    q->head = q->tail = newnode;
  } else {
    newnode->next = q->head;
    q->head = newnode;
  }

  return 0;
}

queue_element_t queue_remove(queue_t q)
{
  queue_node_ptr_t node;
  queue_element_t e;

  if (!q)
    return NULL;

  if (q->head == NULL)
    return NULL;

  node = q->head;
  q->head = q->head->next;
  if (q->head == NULL)
    q->tail = NULL;

  e = node->element;
  free(node);

  return e;
}

queue_element_t queue_head(queue_t q)
{
  if (!q)
    return NULL;

  if (q->head == NULL)
    return NULL;

  return q->head->element;
}

void queue_destroy(queue_t q)
{
  queue_node_ptr_t p, temp;

  if (!q)
    return;

  p = q->head;
  while (p != NULL) {
    free(p->element);
    temp = p;
    p = p->next;
    free(temp);
  }

  free(q);
}

int queue_map(queue_t q, int (*f) (queue_element_t, void *), void *vp)
{
  queue_node_ptr_t p;
  int ret;

  if (!q)
    return 0;

  p = q->head;
  while (p != NULL) {
    ret = f(p->element, vp);
    if (ret)
      return ret;
    p = p->next;
  }
  return 0;
}

void queue_map_remove_on_error(queue_t q,
             int (*f) (queue_element_t, void *),
             void (*g) (queue_element_t, void *), void *vp)
{
  queue_node_ptr_t p, last, temp;
  int ret;

  if (!q)
    return;

  last = NULL;
  p = q->head;
  while (p != NULL) {
    ret = f(p->element, vp);
    if (ret) {
      if (last) {
        last->next = p->next;
        if (last->next == NULL)
          q->tail = last;
      } else {
        q->head = p->next;
        if (q->head == NULL)
          q->tail = NULL;
      }

      temp = p;
      p = p->next;
      g(temp->element, vp);
      free(temp);
    } else {
      last = p;
      p = p->next;
    }
  }

  return;
}

/* FLASK */

Line	Count	Source (jump to first uncovered line)
1
2		/* Author : Stephen Smalley, <stephen.smalley.work@gmail.com> */
3
4		/* FLASK */
5
6		/*
7		* Implementation of the double-ended queue type.
8		*/
9
10		#include <stdlib.h>
11		#include "queue.h"
12
13		queue_t queue_create(void)
14	39	{
15	39	queue_t q;
16
17	39	q = (queue_t) malloc(sizeof(struct queue_info));
18	39	if (q == NULL)
19	0	return NULL;
20
21	39	q->head = q->tail = NULL;
22
23	39	return q;
24	39	}
25
26		int queue_insert(queue_t q, queue_element_t e)
27	0	{
28	0	queue_node_ptr_t newnode;
29
30	0	if (!q)
31	0	return -1;
32
33	0	newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
34	0	if (newnode == NULL)
35	0	return -1;
36
37	0	newnode->element = e;
38	0	newnode->next = NULL;
39
40	0	if (q->head == NULL) {
41	0	q->head = q->tail = newnode;
42	0	} else {
43	0	q->tail->next = newnode;
44	0	q->tail = newnode;
45	0	}
46
47	0	return 0;
48	0	}
49
50		int queue_push(queue_t q, queue_element_t e)
51	0	{
52	0	queue_node_ptr_t newnode;
53
54	0	if (!q)
55	0	return -1;
56
57	0	newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
58	0	if (newnode == NULL)
59	0	return -1;
60
61	0	newnode->element = e;
62	0	newnode->next = NULL;
63
64	0	if (q->head == NULL) {
65	0	q->head = q->tail = newnode;
66	0	} else {
67	0	newnode->next = q->head;
68	0	q->head = newnode;
69	0	}
70
71	0	return 0;
72	0	}
73
74		queue_element_t queue_remove(queue_t q)
75	0	{
76	0	queue_node_ptr_t node;
77	0	queue_element_t e;
78
79	0	if (!q)
80	0	return NULL;
81
82	0	if (q->head == NULL)
83	0	return NULL;
84
85	0	node = q->head;
86	0	q->head = q->head->next;
87	0	if (q->head == NULL)
88	0	q->tail = NULL;
89
90	0	e = node->element;
91	0	free(node);
92
93	0	return e;
94	0	}
95
96		queue_element_t queue_head(queue_t q)
97	0	{
98	0	if (!q)
99	0	return NULL;
100
101	0	if (q->head == NULL)
102	0	return NULL;
103
104	0	return q->head->element;
105	0	}
106
107		void queue_destroy(queue_t q)
108	39	{
109	39	queue_node_ptr_t p, temp;
110
111	39	if (!q)
112	0	return;
113
114	39	p = q->head;
115	39	while (p != NULL) {
116	0	free(p->element);
117	0	temp = p;
118	0	p = p->next;
119	0	free(temp);
120	0	}
121
122	39	free(q);
123	39	}
124
125		int queue_map(queue_t q, int (f) (queue_element_t, void ), void *vp)
126	0	{
127	0	queue_node_ptr_t p;
128	0	int ret;
129
130	0	if (!q)
131	0	return 0;
132
133	0	p = q->head;
134	0	while (p != NULL) {
135	0	ret = f(p->element, vp);
136	0	if (ret)
137	0	return ret;
138	0	p = p->next;
139	0	}
140	0	return 0;
141	0	}
142
143		void queue_map_remove_on_error(queue_t q,
144		int (f) (queue_element_t, void ),
145		void (g) (queue_element_t, void ), void *vp)
146	0	{
147	0	queue_node_ptr_t p, last, temp;
148	0	int ret;
149
150	0	if (!q)
151	0	return;
152
153	0	last = NULL;
154	0	p = q->head;
155	0	while (p != NULL) {
156	0	ret = f(p->element, vp);
157	0	if (ret) {
158	0	if (last) {
159	0	last->next = p->next;
160	0	if (last->next == NULL)
161	0	q->tail = last;
162	0	} else {
163	0	q->head = p->next;
164	0	if (q->head == NULL)
165	0	q->tail = NULL;
166	0	}
167
168	0	temp = p;
169	0	p = p->next;
170	0	g(temp->element, vp);
171	0	free(temp);
172	0	} else {
173	0	last = p;
174	0	p = p->next;
175	0	}
176	0	}
177
178	0	return;
179	0	}
180
181		/* FLASK */

Coverage Report

Created: 2024-10-16 06:49