/src/selinux/checkpolicy/queue.c

Source

/* 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_clear(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);
  }

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

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
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	2.94k	{
15	2.94k	queue_t q;
16
17	2.94k	q = (queue_t) malloc(sizeof(struct queue_info));
18	2.94k	if (q == NULL)
19	0	return NULL;
20
21	2.94k	q->head = q->tail = NULL;
22
23	2.94k	return q;
24	2.94k	}
25
26		int queue_insert(queue_t q, queue_element_t e)
27	2.71M	{
28	2.71M	queue_node_ptr_t newnode;
29
30	2.71M	if (!q)
31	0	return -1;
32
33	2.71M	newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
34	2.71M	if (newnode == NULL)
35	0	return -1;
36
37	2.71M	newnode->element = e;
38	2.71M	newnode->next = NULL;
39
40	2.71M	if (q->head == NULL) {
41	1.54M	q->head = q->tail = newnode;
42	1.54M	} else {
43	1.16M	q->tail->next = newnode;
44	1.16M	q->tail = newnode;
45	1.16M	}
46
47	2.71M	return 0;
48	2.71M	}
49
50		int queue_push(queue_t q, queue_element_t e)
51	84.7k	{
52	84.7k	queue_node_ptr_t newnode;
53
54	84.7k	if (!q)
55	0	return -1;
56
57	84.7k	newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
58	84.7k	if (newnode == NULL)
59	0	return -1;
60
61	84.7k	newnode->element = e;
62	84.7k	newnode->next = NULL;
63
64	84.7k	if (q->head == NULL) {
65	0	q->head = q->tail = newnode;
66	84.7k	} else {
67	84.7k	newnode->next = q->head;
68	84.7k	q->head = newnode;
69	84.7k	}
70
71	84.7k	return 0;
72	84.7k	}
73
74		queue_element_t queue_remove(queue_t q)
75	3.05M	{
76	3.05M	queue_node_ptr_t node;
77	3.05M	queue_element_t e;
78
79	3.05M	if (!q)
80	0	return NULL;
81
82	3.05M	if (q->head == NULL)
83	409k	return NULL;
84
85	2.64M	node = q->head;
86	2.64M	q->head = q->head->next;
87	2.64M	if (q->head == NULL)
88	1.54M	q->tail = NULL;
89
90	2.64M	e = node->element;
91	2.64M	free(node);
92
93	2.64M	return e;
94	3.05M	}
95
96		queue_element_t queue_head(queue_t q)
97	15.2k	{
98	15.2k	if (!q)
99	0	return NULL;
100
101	15.2k	if (q->head == NULL)
102	0	return NULL;
103
104	15.2k	return q->head->element;
105	15.2k	}
106
107		void queue_clear(queue_t q)
108	5.31k	{
109	5.31k	queue_node_ptr_t p, temp;
110
111	5.31k	if (!q)
112	0	return;
113
114	5.31k	p = q->head;
115	5.90k	while (p != NULL) {
116	592	free(p->element);
117	592	temp = p;
118	592	p = p->next;
119	592	free(temp);
120	592	}
121
122	5.31k	q->head = q->tail = NULL;
123	5.31k	}
124
125		void queue_destroy(queue_t q)
126	2.94k	{
127	2.94k	queue_node_ptr_t p, temp;
128
129	2.94k	if (!q)
130	0	return;
131
132	2.94k	p = q->head;
133	157k	while (p != NULL) {
134	154k	free(p->element);
135	154k	temp = p;
136	154k	p = p->next;
137	154k	free(temp);
138	154k	}
139
140	2.94k	free(q);
141	2.94k	}
142
143		int queue_map(queue_t q, int (f) (queue_element_t, void ), void *vp)
144	0	{
145	0	queue_node_ptr_t p;
146	0	int ret;
147
148	0	if (!q)
149	0	return 0;
150
151	0	p = q->head;
152	0	while (p != NULL) {
153	0	ret = f(p->element, vp);
154	0	if (ret)
155	0	return ret;
156	0	p = p->next;
157	0	}
158	0	return 0;
159	0	}
160
161		void queue_map_remove_on_error(queue_t q,
162		int (f) (queue_element_t, void ),
163		void (g) (queue_element_t, void ), void *vp)
164	0	{
165	0	queue_node_ptr_t p, last, temp;
166	0	int ret;
167
168	0	if (!q)
169	0	return;
170
171	0	last = NULL;
172	0	p = q->head;
173	0	while (p != NULL) {
174	0	ret = f(p->element, vp);
175	0	if (ret) {
176	0	if (last) {
177	0	last->next = p->next;
178	0	if (last->next == NULL)
179	0	q->tail = last;
180	0	} else {
181	0	q->head = p->next;
182	0	if (q->head == NULL)
183	0	q->tail = NULL;
184	0	}
185
186	0	temp = p;
187	0	p = p->next;
188	0	g(temp->element, vp);
189	0	free(temp);
190	0	} else {
191	0	last = p;
192	0	p = p->next;
193	0	}
194	0	}
195
196	0	return;
197	0	}
198
199		/* FLASK */

Coverage Report

Created: 2026-04-01 06:36