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

Coverage Report

Created: 2026-06-10 07:00