/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.54k	{
15	3.54k	queue_t q;
16
17	3.54k	q = (queue_t) malloc(sizeof(struct queue_info));
18	3.54k	if (q == NULL)
19	0	return NULL;
20
21	3.54k	q->head = q->tail = NULL;
22
23	3.54k	return q;
24	3.54k	}
25
26		int queue_insert(queue_t q, queue_element_t e)
27	2.80M	{
28	2.80M	queue_node_ptr_t newnode;
29
30	2.80M	if (!q)
31	0	return -1;
32
33	2.80M	newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
34	2.80M	if (newnode == NULL)
35	0	return -1;
36
37	2.80M	newnode->element = e;
38	2.80M	newnode->next = NULL;
39
40	2.80M	if (q->head == NULL) {
41	1.23M	q->head = q->tail = newnode;
42	1.56M	} else {
43	1.56M	q->tail->next = newnode;
44	1.56M	q->tail = newnode;
45	1.56M	}
46
47	2.80M	return 0;
48	2.80M	}
49
50		int queue_push(queue_t q, queue_element_t e)
51	107k	{
52	107k	queue_node_ptr_t newnode;
53
54	107k	if (!q)
55	0	return -1;
56
57	107k	newnode = (queue_node_ptr_t) malloc(sizeof(struct queue_node));
58	107k	if (newnode == NULL)
59	0	return -1;
60
61	107k	newnode->element = e;
62	107k	newnode->next = NULL;
63
64	107k	if (q->head == NULL) {
65	0	q->head = q->tail = newnode;
66	107k	} else {
67	107k	newnode->next = q->head;
68	107k	q->head = newnode;
69	107k	}
70
71	107k	return 0;
72	107k	}
73
74		queue_element_t queue_remove(queue_t q)
75	3.11M	{
76	3.11M	queue_node_ptr_t node;
77	3.11M	queue_element_t e;
78
79	3.11M	if (!q)
80	0	return NULL;
81
82	3.11M	if (q->head == NULL)
83	417k	return NULL;
84
85	2.70M	node = q->head;
86	2.70M	q->head = q->head->next;
87	2.70M	if (q->head == NULL)
88	1.23M	q->tail = NULL;
89
90	2.70M	e = node->element;
91	2.70M	free(node);
92
93	2.70M	return e;
94	3.11M	}
95
96		queue_element_t queue_head(queue_t q)
97	20.3k	{
98	20.3k	if (!q)
99	0	return NULL;
100
101	20.3k	if (q->head == NULL)
102	0	return NULL;
103
104	20.3k	return q->head->element;
105	20.3k	}
106
107		void queue_clear(queue_t q)
108	6.43k	{
109	6.43k	queue_node_ptr_t p, temp;
110
111	6.43k	if (!q)
112	0	return;
113
114	6.43k	p = q->head;
115	6.74k	while (p != NULL) {
116	311	free(p->element);
117	311	temp = p;
118	311	p = p->next;
119	311	free(temp);
120	311	}
121
122	6.43k	q->head = q->tail = NULL;
123	6.43k	}
124
125		void queue_destroy(queue_t q)
126	3.54k	{
127	3.54k	queue_node_ptr_t p, temp;
128
129	3.54k	if (!q)
130	0	return;
131
132	3.54k	p = q->head;
133	216k	while (p != NULL) {
134	212k	free(p->element);
135	212k	temp = p;
136	212k	p = p->next;
137	212k	free(temp);
138	212k	}
139
140	3.54k	free(q);
141	3.54k	}
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-01-10 06:30