This graph shows which files directly or indirectly include this file:

Macros
#define	_Q_ASSERT(a)

#define	CIRCLEQ_HEAD(name, type)

#define	CIRCLEQ_HEAD_INITIALIZER(head) { CIRCLEQ_END(&head), CIRCLEQ_END(&head) }

#define	CIRCLEQ_ENTRY(type)

#define	CIRCLEQ_FIRST(head) ((head)->cqh_first)

#define	CIRCLEQ_LAST(head) ((head)->cqh_last)

#define	CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)

#define	CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)

#define	CIRCLEQ_EMPTY(head) (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))

#define	CIRCLEQ_FOREACH(var, head, field)

#define	CIRCLEQ_FOREACH_SAFE(var, head, field, tvar)

#define	CIRCLEQ_FOREACH_REVERSE(var, head, field)

#define	CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)

#define	CIRCLEQ_INIT(head)

#define	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field)

#define	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field)

#define	CIRCLEQ_INSERT_HEAD(head, elm, field)

#define	CIRCLEQ_INSERT_TAIL(head, elm, field)

#define	CIRCLEQ_REMOVE(head, elm, field)

#define	CIRCLEQ_REPLACE(head, elm, elm2, field)

#define	CIRCLEQ_END(head) ((void *)(head))

#define	TAILQ_HEAD(name, type)

#define	TAILQ_HEAD_INITIALIZER(head) { NULL, &(head).tqh_first }

#define	TAILQ_ENTRY(type)

#define	TAILQ_EMPTY(head) ((head)->tqh_first == NULL)

#define	TAILQ_FIRST(head) ((head)->tqh_first)

#define	TAILQ_FOREACH(var, head, field)

#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)

#define	TAILQ_INIT(head)

#define	TAILQ_INSERT_AFTER(head, listelm, elm, field)

#define	TAILQ_INSERT_BEFORE(listelm, elm, field)

#define	TAILQ_INSERT_HEAD(head, elm, field)

#define	TAILQ_INSERT_TAIL(head, elm, field)

#define	TAILQ_LAST(head, headname) ((((struct headname )((head)->tqh_last))->tqh_last))

#define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)

#define	TAILQ_PREV(elm, headname, field) ((((struct headname )((elm)->field.tqe_prev))->tqh_last))

#define	TAILQ_REMOVE(head, elm, field)

#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)

Macro Definition Documentation

◆ _Q_ASSERT

#define _Q_ASSERT ( a )

This file started as a copy of sys/queue.h from OpenBSD and then had various changes made over time. Now we include the system sys/queue.h and then add missing behavior. On Windows this means we basically add everything. This allows for Suricata builds that integrate with other libraries that make use of sys/queue.h to use the exact same definitions from queue.h instead the Suricata copy.

Definition at line 61 of file queue.h.

◆ CIRCLEQ_EMPTY

#define CIRCLEQ_EMPTY ( head ) (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))

Definition at line 99 of file queue.h.

◆ CIRCLEQ_END

#define CIRCLEQ_END ( head ) ((void *)(head))

Definition at line 202 of file queue.h.

◆ CIRCLEQ_ENTRY

#define CIRCLEQ_ENTRY ( type )

Value:

struct {                                \
    struct type *cqe_next;      /* next element */      \
    struct type *cqe_prev;      /* previous element */      \
}

Definition at line 86 of file queue.h.

◆ CIRCLEQ_FIRST

#define CIRCLEQ_FIRST ( head ) ((head)->cqh_first)

Definition at line 95 of file queue.h.

◆ CIRCLEQ_FOREACH

#define CIRCLEQ_FOREACH	(	var,
		head,
		field
	)

Value:

    for((var) = CIRCLEQ_FIRST(head);                \
        (var) != CIRCLEQ_END(head);                 \
        (var) = CIRCLEQ_NEXT(var, field))

Definition at line 102 of file queue.h.

◆ CIRCLEQ_FOREACH_REVERSE

#define CIRCLEQ_FOREACH_REVERSE	(	var,
		head,
		field
	)

Value:

    for((var) = CIRCLEQ_LAST(head);                 \
        (var) != CIRCLEQ_END(head);                 \
        (var) = CIRCLEQ_PREV(var, field))

Definition at line 113 of file queue.h.

◆ CIRCLEQ_FOREACH_REVERSE_SAFE

#define CIRCLEQ_FOREACH_REVERSE_SAFE	(	var,
		head,
		headname,
		field,
		tvar
	)

Value:

    for ((var) = CIRCLEQ_LAST(head, headname);          \
        (var) != CIRCLEQ_END(head) &&               \
        ((tvar) = CIRCLEQ_PREV(var, headname, field), 1);       \
        (var) = (tvar))

Definition at line 118 of file queue.h.

◆ CIRCLEQ_FOREACH_SAFE

#define CIRCLEQ_FOREACH_SAFE	(	var,
		head,
		field,
		tvar
	)

Value:

    for ((var) = CIRCLEQ_FIRST(head);               \
        (var) != CIRCLEQ_END(head) &&               \
        ((tvar) = CIRCLEQ_NEXT(var, field), 1);         \
        (var) = (tvar))

Definition at line 107 of file queue.h.

◆ CIRCLEQ_HEAD

#define CIRCLEQ_HEAD	(	name,
		type
	)

Value:

struct name {                               \
    struct type *cqh_first;     /* first element */     \
    struct type *cqh_last;      /* last element */      \
}

Definition at line 77 of file queue.h.

◆ CIRCLEQ_HEAD_INITIALIZER

#define CIRCLEQ_HEAD_INITIALIZER ( head ) { CIRCLEQ_END(&head), CIRCLEQ_END(&head) }

Definition at line 83 of file queue.h.

◆ CIRCLEQ_INIT

#define CIRCLEQ_INIT ( head )

Value:

    do {                        \
    (head)->cqh_first = CIRCLEQ_END(head);              \
    (head)->cqh_last = CIRCLEQ_END(head);               \
} while (0)

Definition at line 127 of file queue.h.

◆ CIRCLEQ_INSERT_AFTER

#define CIRCLEQ_INSERT_AFTER	(	head,
		listelm,
		elm,
		field
	)

Value:

    do {        \
    (elm)->field.cqe_next = (listelm)->field.cqe_next;      \
    (elm)->field.cqe_prev = (listelm);              \
    if ((listelm)->field.cqe_next == CIRCLEQ_END(head))     \
        (head)->cqh_last = (elm);               \
    else                                \
        (listelm)->field.cqe_next->field.cqe_prev = (elm);  \
    (listelm)->field.cqe_next = (elm);              \
} while (0)

Definition at line 132 of file queue.h.

◆ CIRCLEQ_INSERT_BEFORE

#define CIRCLEQ_INSERT_BEFORE	(	head,
		listelm,
		elm,
		field
	)

Value:

    do {        \
    (elm)->field.cqe_next = (listelm);              \
    (elm)->field.cqe_prev = (listelm)->field.cqe_prev;      \
    if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))     \
        (head)->cqh_first = (elm);              \
    else                                \
        (listelm)->field.cqe_prev->field.cqe_next = (elm);  \
    (listelm)->field.cqe_prev = (elm);              \
} while (0)

Definition at line 142 of file queue.h.

◆ CIRCLEQ_INSERT_HEAD

#define CIRCLEQ_INSERT_HEAD	(	head,
		elm,
		field
	)

Value:

    do {            \
    (elm)->field.cqe_next = (head)->cqh_first;          \
    (elm)->field.cqe_prev = CIRCLEQ_END(head);          \
    if ((head)->cqh_last == CIRCLEQ_END(head))          \
        (head)->cqh_last = (elm);               \
    else                                \
        (head)->cqh_first->field.cqe_prev = (elm);      \
    (head)->cqh_first = (elm);                  \
} while (0)

Definition at line 152 of file queue.h.

◆ CIRCLEQ_INSERT_TAIL

#define CIRCLEQ_INSERT_TAIL	(	head,
		elm,
		field
	)

Value:

    do {            \
    (elm)->field.cqe_next = CIRCLEQ_END(head);          \
    (elm)->field.cqe_prev = (head)->cqh_last;           \
    if ((head)->cqh_first == CIRCLEQ_END(head))         \
        (head)->cqh_first = (elm);              \
    else                                \
        (head)->cqh_last->field.cqe_next = (elm);       \
    (head)->cqh_last = (elm);                   \
} while (0)

Definition at line 162 of file queue.h.

◆ CIRCLEQ_LAST

#define CIRCLEQ_LAST ( head ) ((head)->cqh_last)

Definition at line 96 of file queue.h.

◆ CIRCLEQ_NEXT

#define CIRCLEQ_NEXT	(	elm,
		field
	)	((elm)->field.cqe_next)

Definition at line 97 of file queue.h.

◆ CIRCLEQ_PREV

#define CIRCLEQ_PREV	(	elm,
		field
	)	((elm)->field.cqe_prev)

Definition at line 98 of file queue.h.

◆ CIRCLEQ_REMOVE

#define CIRCLEQ_REMOVE	(	head,
		elm,
		field
	)

Value:

    do {                \
    if ((elm)->field.cqe_next == CIRCLEQ_END(head))         \
        (head)->cqh_last = (elm)->field.cqe_prev;       \
    else                                \
        (elm)->field.cqe_next->field.cqe_prev =         \
            (elm)->field.cqe_prev;              \
    if ((elm)->field.cqe_prev == CIRCLEQ_END(head))         \
        (head)->cqh_first = (elm)->field.cqe_next;      \
    else                                \
        (elm)->field.cqe_prev->field.cqe_next =         \
            (elm)->field.cqe_next;              \
} while (0)

Definition at line 172 of file queue.h.

◆ CIRCLEQ_REPLACE

#define CIRCLEQ_REPLACE	(	head,
		elm,
		elm2,
		field
	)

Value:

    do {            \
    if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==     \
        CIRCLEQ_END(head))                      \
        (head)->cqh_last = (elm2);              \
    else                                \
        (elm2)->field.cqe_next->field.cqe_prev = (elm2);    \
    if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==     \
        CIRCLEQ_END(head))                      \
        (head)->cqh_first = (elm2);             \
    else                                \
        (elm2)->field.cqe_prev->field.cqe_next = (elm2);    \
} while (0)

Definition at line 185 of file queue.h.

◆ TAILQ_EMPTY

#define TAILQ_EMPTY ( head ) ((head)->tqh_first == NULL)

Definition at line 249 of file queue.h.

◆ TAILQ_ENTRY

#define TAILQ_ENTRY ( type )

Value:

struct {                                \
    struct type *tqe_next;  /* next element */          \
    struct type **tqe_prev; /* address of previous next element */  \
}

Definition at line 240 of file queue.h.

◆ TAILQ_FIRST

#define TAILQ_FIRST ( head ) ((head)->tqh_first)

Definition at line 251 of file queue.h.

◆ TAILQ_FOREACH

#define TAILQ_FOREACH	(	var,
		head,
		field
	)

Value:

    for ((var) = TAILQ_FIRST((head));               \
        (var);                          \
        (var) = TAILQ_NEXT((var), field))

Definition at line 253 of file queue.h.

◆ TAILQ_FOREACH_REVERSE

#define TAILQ_FOREACH_REVERSE	(	var,
		head,
		headname,
		field
	)

Value:

    for ((var) = TAILQ_LAST((head), headname);          \
        (var);                          \
        (var) = TAILQ_PREV((var), headname, field))

Definition at line 258 of file queue.h.

◆ TAILQ_FOREACH_SAFE

#define TAILQ_FOREACH_SAFE	(	var,
		head,
		field,
		tvar
	)

Value:

    for ((var) = TAILQ_FIRST((head));               \
        (var) && ((tvar) = TAILQ_NEXT((var), field), 1);        \
        (var) = (tvar))

Definition at line 330 of file queue.h.

◆ TAILQ_HEAD

#define TAILQ_HEAD	(	name,
		type
	)

Value:

struct name {                               \
    struct type *tqh_first; /* first element */         \
    struct type **tqh_last; /* addr of last next element */     \
}

Definition at line 231 of file queue.h.

◆ TAILQ_HEAD_INITIALIZER

#define TAILQ_HEAD_INITIALIZER ( head ) { NULL, &(head).tqh_first }

Definition at line 237 of file queue.h.

◆ TAILQ_INIT

#define TAILQ_INIT ( head )

Value:

    do {                        \
    TAILQ_FIRST((head)) = NULL;                 \
    (head)->tqh_last = &TAILQ_FIRST((head));            \
} while (0)

Definition at line 263 of file queue.h.

◆ TAILQ_INSERT_AFTER

#define TAILQ_INSERT_AFTER	(	head,
		listelm,
		elm,
		field
	)

Value:

    do {        \
    if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
            &TAILQ_NEXT((elm), field);              \
    else                                \
        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
    TAILQ_NEXT((listelm), field) = (elm);               \
    (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);      \
} while (0)

Definition at line 268 of file queue.h.

◆ TAILQ_INSERT_BEFORE

#define TAILQ_INSERT_BEFORE	(	listelm,
		elm,
		field
	)

Value:

    do {            \
    (elm)->field.tqe_prev = (listelm)->field.tqe_prev;      \
    TAILQ_NEXT((elm), field) = (listelm);               \
    *(listelm)->field.tqe_prev = (elm);             \
    (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);      \
} while (0)

Definition at line 278 of file queue.h.

◆ TAILQ_INSERT_HEAD

#define TAILQ_INSERT_HEAD	(	head,
		elm,
		field
	)

Value:

    do {            \
    if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)   \
        TAILQ_FIRST((head))->field.tqe_prev =           \
            &TAILQ_NEXT((elm), field);              \
    else                                \
        (head)->tqh_last = &TAILQ_NEXT((elm), field);       \
    TAILQ_FIRST((head)) = (elm);                    \
    (elm)->field.tqe_prev = &TAILQ_FIRST((head));           \
} while (0)

Definition at line 285 of file queue.h.

◆ TAILQ_INSERT_TAIL

#define TAILQ_INSERT_TAIL	(	head,
		elm,
		field
	)

Value:

    do {            \
    _Q_ASSERT((elm));                       \
    _Q_ASSERT((head));                      \
    TAILQ_NEXT((elm), field) = NULL;                \
    (elm)->field.tqe_prev = (head)->tqh_last;           \
    *(head)->tqh_last = (elm);                  \
    _Q_ASSERT(*(head)->tqh_last);                   \
    (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
} while (0)

Definition at line 295 of file queue.h.

◆ TAILQ_LAST

#define TAILQ_LAST	(	head,
		headname
	)	((((struct headname )((head)->tqh_last))->tqh_last))

Definition at line 305 of file queue.h.

◆ TAILQ_NEXT

#define TAILQ_NEXT	(	elm,
		field
	)	((elm)->field.tqe_next)

Definition at line 308 of file queue.h.

◆ TAILQ_PREV

#define TAILQ_PREV	(	elm,
		headname,
		field
	)	((((struct headname )((elm)->field.tqe_prev))->tqh_last))

Definition at line 310 of file queue.h.

◆ TAILQ_REMOVE

#define TAILQ_REMOVE	(	head,
		elm,
		field
	)

Value:

    do {                \
    if ((TAILQ_NEXT((elm), field)) != NULL)             \
        TAILQ_NEXT((elm), field)->field.tqe_prev =      \
            (elm)->field.tqe_prev;              \
    else                                \
        (head)->tqh_last = (elm)->field.tqe_prev;       \
    _Q_ASSERT((head)->tqh_first != (elm));              \
    *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);      \
} while (0)

Definition at line 313 of file queue.h.

Macros

Macro Definition Documentation

◆ _Q_ASSERT

◆ CIRCLEQ_EMPTY

◆ CIRCLEQ_END

◆ CIRCLEQ_ENTRY

◆ CIRCLEQ_FIRST

◆ CIRCLEQ_FOREACH

◆ CIRCLEQ_FOREACH_REVERSE

◆ CIRCLEQ_FOREACH_REVERSE_SAFE

◆ CIRCLEQ_FOREACH_SAFE

◆ CIRCLEQ_HEAD

◆ CIRCLEQ_HEAD_INITIALIZER

◆ CIRCLEQ_INIT

◆ CIRCLEQ_INSERT_AFTER

◆ CIRCLEQ_INSERT_BEFORE

◆ CIRCLEQ_INSERT_HEAD

◆ CIRCLEQ_INSERT_TAIL

◆ CIRCLEQ_LAST

◆ CIRCLEQ_NEXT

◆ CIRCLEQ_PREV

◆ CIRCLEQ_REMOVE

◆ CIRCLEQ_REPLACE

◆ TAILQ_EMPTY

◆ TAILQ_ENTRY

◆ TAILQ_FIRST

◆ TAILQ_FOREACH

◆ TAILQ_FOREACH_REVERSE

◆ TAILQ_FOREACH_SAFE

◆ TAILQ_HEAD

◆ TAILQ_HEAD_INITIALIZER

◆ TAILQ_INIT

◆ TAILQ_INSERT_AFTER

◆ TAILQ_INSERT_BEFORE

◆ TAILQ_INSERT_HEAD

◆ TAILQ_INSERT_TAIL

◆ TAILQ_LAST

◆ TAILQ_NEXT

◆ TAILQ_PREV

◆ TAILQ_REMOVE