Rename all of the macros in tor_queue.h to start with TOR_
This commit is contained in:
Nick Mathewson
parent
29136bd7e4
commit
35daf6f602
|
|
@ -0,0 +1,6 @@
|
|||
o Major bugfixes:
|
||||
- Rename all macros in our local copy of queue.h to begin with TOR_;
|
||||
this seems the only good way to permanently prevent conflicts
|
||||
with queue.h on various operating systems. Fixes bug 8107; bugfix on
|
||||
0.2.4.6-alpha.
|
||||
|
||||
|
|
@ -34,7 +34,9 @@ tor_queue.h
|
|||
A copy of sys/queue.h from OpenBSD. We keep our own copy rather
|
||||
than using sys/queue.h, since some platforms don't have a
|
||||
sys/queue.h, and the ones that do have diverged in incompatible
|
||||
ways. (CIRCLEQ or no CIRCLEQ? SIMPLQ or STAILQ?)
|
||||
ways. (CIRCLEQ or no CIRCLEQ? SIMPLQ or STAILQ?) We also rename
|
||||
the identifiers with a TOR_ prefix to avoid conflicts with
|
||||
the system headers.
|
||||
|
||||
curve25519_donna/*.c
|
||||
|
||||
|
|
|
|||
|
|
@ -32,8 +32,8 @@
|
|||
* @(#)queue.h 8.5 (Berkeley) 8/20/94
|
||||
*/
|
||||
|
||||
#ifndef _SYS_QUEUE_H_
|
||||
#define _SYS_QUEUE_H_
|
||||
#ifndef TOR_QUEUE_H_
|
||||
#define TOR_QUEUE_H_
|
||||
|
||||
/*
|
||||
* This file defines five types of data structures: singly-linked lists,
|
||||
|
|
@ -83,78 +83,73 @@
|
|||
*/
|
||||
|
||||
#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC))
|
||||
#define _Q_INVALIDATE(a) (a) = ((void *)-1)
|
||||
#define TOR_Q_INVALIDATE_(a) (a) = ((void *)-1)
|
||||
#else
|
||||
#define _Q_INVALIDATE(a)
|
||||
#define TOR_Q_INVALIDATE_(a)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Singly-linked List definitions.
|
||||
*/
|
||||
#define SLIST_HEAD(name, type) \
|
||||
#define TOR_SLIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *slh_first; /* first element */ \
|
||||
}
|
||||
|
||||
#define SLIST_HEAD_INITIALIZER(head) \
|
||||
#define TOR_SLIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
/* XXXX This macro name conflicts with a typedef in winnt.h, so Tor
|
||||
* has to redefine it. */
|
||||
#define TOR_SLIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *sle_next; /* next element */ \
|
||||
}
|
||||
#ifndef _WIN32
|
||||
#define SLIST_ENTRY(type) TOR_SLIST_ENTRY(type)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Singly-linked List access methods.
|
||||
*/
|
||||
#define SLIST_FIRST(head) ((head)->slh_first)
|
||||
#define SLIST_END(head) NULL
|
||||
#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head))
|
||||
#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
|
||||
#define TOR_SLIST_FIRST(head) ((head)->slh_first)
|
||||
#define TOR_SLIST_END(head) NULL
|
||||
#define TOR_SLIST_EMPTY(head) (SLIST_FIRST(head) == TOR_SLIST_END(head))
|
||||
#define TOR_SLIST_NEXT(elm, field) ((elm)->field.sle_next)
|
||||
|
||||
#define SLIST_FOREACH(var, head, field) \
|
||||
for((var) = SLIST_FIRST(head); \
|
||||
(var) != SLIST_END(head); \
|
||||
(var) = SLIST_NEXT(var, field))
|
||||
#define TOR_SLIST_FOREACH(var, head, field) \
|
||||
for((var) = TOR_SLIST_FIRST(head); \
|
||||
(var) != TOR_SLIST_END(head); \
|
||||
(var) = TOR_SLIST_NEXT(var, field))
|
||||
|
||||
#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = SLIST_FIRST(head); \
|
||||
(var) && ((tvar) = SLIST_NEXT(var, field), 1); \
|
||||
#define TOR_SLIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TOR_SLIST_FIRST(head); \
|
||||
(var) && ((tvar) = TOR_SLIST_NEXT(var, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
/*
|
||||
* Singly-linked List functions.
|
||||
*/
|
||||
#define SLIST_INIT(head) { \
|
||||
SLIST_FIRST(head) = SLIST_END(head); \
|
||||
#define TOR_SLIST_INIT(head) { \
|
||||
TOR_SLIST_FIRST(head) = TOR_SLIST_END(head); \
|
||||
}
|
||||
|
||||
#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
|
||||
#define TOR_SLIST_INSERT_AFTER(slistelm, elm, field) do { \
|
||||
(elm)->field.sle_next = (slistelm)->field.sle_next; \
|
||||
(slistelm)->field.sle_next = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_INSERT_HEAD(head, elm, field) do { \
|
||||
#define TOR_SLIST_INSERT_HEAD(head, elm, field) do { \
|
||||
(elm)->field.sle_next = (head)->slh_first; \
|
||||
(head)->slh_first = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_REMOVE_AFTER(elm, field) do { \
|
||||
#define TOR_SLIST_REMOVE_AFTER(elm, field) do { \
|
||||
(elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_REMOVE_HEAD(head, field) do { \
|
||||
#define TOR_SLIST_REMOVE_HEAD(head, field) do { \
|
||||
(head)->slh_first = (head)->slh_first->field.sle_next; \
|
||||
} while (0)
|
||||
|
||||
#define SLIST_REMOVE(head, elm, type, field) do { \
|
||||
#define TOR_SLIST_REMOVE(head, elm, type, field) do { \
|
||||
if ((head)->slh_first == (elm)) { \
|
||||
SLIST_REMOVE_HEAD((head), field); \
|
||||
TOR_SLIST_REMOVE_HEAD((head), field); \
|
||||
} else { \
|
||||
struct type *curelm = (head)->slh_first; \
|
||||
\
|
||||
|
|
@ -162,22 +157,22 @@ struct { \
|
|||
curelm = curelm->field.sle_next; \
|
||||
curelm->field.sle_next = \
|
||||
curelm->field.sle_next->field.sle_next; \
|
||||
_Q_INVALIDATE((elm)->field.sle_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.sle_next); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* List definitions.
|
||||
*/
|
||||
#define LIST_HEAD(name, type) \
|
||||
#define TOR_LIST_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *lh_first; /* first element */ \
|
||||
}
|
||||
|
||||
#define LIST_HEAD_INITIALIZER(head) \
|
||||
#define TOR_LIST_HEAD_INITIALIZER(head) \
|
||||
{ NULL }
|
||||
|
||||
#define LIST_ENTRY(type) \
|
||||
#define TOR_LIST_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *le_next; /* next element */ \
|
||||
struct type **le_prev; /* address of previous next element */ \
|
||||
|
|
@ -186,29 +181,29 @@ struct { \
|
|||
/*
|
||||
* List access methods
|
||||
*/
|
||||
#define LIST_FIRST(head) ((head)->lh_first)
|
||||
#define LIST_END(head) NULL
|
||||
#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head))
|
||||
#define LIST_NEXT(elm, field) ((elm)->field.le_next)
|
||||
#define TOR_LIST_FIRST(head) ((head)->lh_first)
|
||||
#define TOR_LIST_END(head) NULL
|
||||
#define TOR_LIST_EMPTY(head) (TOR_LIST_FIRST(head) == TOR_LIST_END(head))
|
||||
#define TOR_LIST_NEXT(elm, field) ((elm)->field.le_next)
|
||||
|
||||
#define LIST_FOREACH(var, head, field) \
|
||||
for((var) = LIST_FIRST(head); \
|
||||
(var)!= LIST_END(head); \
|
||||
(var) = LIST_NEXT(var, field))
|
||||
#define TOR_LIST_FOREACH(var, head, field) \
|
||||
for((var) = TOR_LIST_FIRST(head); \
|
||||
(var)!= TOR_LIST_END(head); \
|
||||
(var) = TOR_LIST_NEXT(var, field))
|
||||
|
||||
#define LIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = LIST_FIRST(head); \
|
||||
(var) && ((tvar) = LIST_NEXT(var, field), 1); \
|
||||
#define TOR_LIST_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TOR_LIST_FIRST(head); \
|
||||
(var) && ((tvar) = TOR_LIST_NEXT(var, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
/*
|
||||
* List functions.
|
||||
*/
|
||||
#define LIST_INIT(head) do { \
|
||||
LIST_FIRST(head) = LIST_END(head); \
|
||||
#define TOR_LIST_INIT(head) do { \
|
||||
TOR_LIST_FIRST(head) = TOR_LIST_END(head); \
|
||||
} while (0)
|
||||
|
||||
#define LIST_INSERT_AFTER(listelm, elm, field) do { \
|
||||
#define TOR_LIST_INSERT_AFTER(listelm, elm, field) do { \
|
||||
if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
|
||||
(listelm)->field.le_next->field.le_prev = \
|
||||
&(elm)->field.le_next; \
|
||||
|
|
@ -216,52 +211,52 @@ struct { \
|
|||
(elm)->field.le_prev = &(listelm)->field.le_next; \
|
||||
} while (0)
|
||||
|
||||
#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
#define TOR_LIST_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
(elm)->field.le_prev = (listelm)->field.le_prev; \
|
||||
(elm)->field.le_next = (listelm); \
|
||||
*(listelm)->field.le_prev = (elm); \
|
||||
(listelm)->field.le_prev = &(elm)->field.le_next; \
|
||||
} while (0)
|
||||
|
||||
#define LIST_INSERT_HEAD(head, elm, field) do { \
|
||||
#define TOR_LIST_INSERT_HEAD(head, elm, field) do { \
|
||||
if (((elm)->field.le_next = (head)->lh_first) != NULL) \
|
||||
(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
|
||||
(head)->lh_first = (elm); \
|
||||
(elm)->field.le_prev = &(head)->lh_first; \
|
||||
} while (0)
|
||||
|
||||
#define LIST_REMOVE(elm, field) do { \
|
||||
#define TOR_LIST_REMOVE(elm, field) do { \
|
||||
if ((elm)->field.le_next != NULL) \
|
||||
(elm)->field.le_next->field.le_prev = \
|
||||
(elm)->field.le_prev; \
|
||||
*(elm)->field.le_prev = (elm)->field.le_next; \
|
||||
_Q_INVALIDATE((elm)->field.le_prev); \
|
||||
_Q_INVALIDATE((elm)->field.le_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.le_prev); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.le_next); \
|
||||
} while (0)
|
||||
|
||||
#define LIST_REPLACE(elm, elm2, field) do { \
|
||||
#define TOR_LIST_REPLACE(elm, elm2, field) do { \
|
||||
if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \
|
||||
(elm2)->field.le_next->field.le_prev = \
|
||||
&(elm2)->field.le_next; \
|
||||
(elm2)->field.le_prev = (elm)->field.le_prev; \
|
||||
*(elm2)->field.le_prev = (elm2); \
|
||||
_Q_INVALIDATE((elm)->field.le_prev); \
|
||||
_Q_INVALIDATE((elm)->field.le_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.le_prev); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.le_next); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Simple queue definitions.
|
||||
*/
|
||||
#define SIMPLEQ_HEAD(name, type) \
|
||||
#define TOR_SIMPLEQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *sqh_first; /* first element */ \
|
||||
struct type **sqh_last; /* addr of last next element */ \
|
||||
}
|
||||
|
||||
#define SIMPLEQ_HEAD_INITIALIZER(head) \
|
||||
#define TOR_SIMPLEQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).sqh_first }
|
||||
|
||||
#define SIMPLEQ_ENTRY(type) \
|
||||
#define TOR_SIMPLEQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *sqe_next; /* next element */ \
|
||||
}
|
||||
|
|
@ -269,53 +264,53 @@ struct { \
|
|||
/*
|
||||
* Simple queue access methods.
|
||||
*/
|
||||
#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
|
||||
#define SIMPLEQ_END(head) NULL
|
||||
#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
|
||||
#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
|
||||
#define TOR_SIMPLEQ_FIRST(head) ((head)->sqh_first)
|
||||
#define TOR_SIMPLEQ_END(head) NULL
|
||||
#define TOR_SIMPLEQ_EMPTY(head) (TOR_SIMPLEQ_FIRST(head) == TOR_SIMPLEQ_END(head))
|
||||
#define TOR_SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
|
||||
|
||||
#define SIMPLEQ_FOREACH(var, head, field) \
|
||||
for((var) = SIMPLEQ_FIRST(head); \
|
||||
(var) != SIMPLEQ_END(head); \
|
||||
(var) = SIMPLEQ_NEXT(var, field))
|
||||
#define TOR_SIMPLEQ_FOREACH(var, head, field) \
|
||||
for((var) = TOR_SIMPLEQ_FIRST(head); \
|
||||
(var) != TOR_SIMPLEQ_END(head); \
|
||||
(var) = TOR_SIMPLEQ_NEXT(var, field))
|
||||
|
||||
#define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = SIMPLEQ_FIRST(head); \
|
||||
(var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1); \
|
||||
#define TOR_SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TOR_SIMPLEQ_FIRST(head); \
|
||||
(var) && ((tvar) = TOR_SIMPLEQ_NEXT(var, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
/*
|
||||
* Simple queue functions.
|
||||
*/
|
||||
#define SIMPLEQ_INIT(head) do { \
|
||||
#define TOR_SIMPLEQ_INIT(head) do { \
|
||||
(head)->sqh_first = NULL; \
|
||||
(head)->sqh_last = &(head)->sqh_first; \
|
||||
} while (0)
|
||||
|
||||
#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
#define TOR_SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
(head)->sqh_first = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
#define TOR_SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
(elm)->field.sqe_next = NULL; \
|
||||
*(head)->sqh_last = (elm); \
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
} while (0)
|
||||
|
||||
#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
#define TOR_SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
(listelm)->field.sqe_next = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define SIMPLEQ_REMOVE_HEAD(head, field) do { \
|
||||
#define TOR_SIMPLEQ_REMOVE_HEAD(head, field) do { \
|
||||
if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
|
||||
(head)->sqh_last = &(head)->sqh_first; \
|
||||
} while (0)
|
||||
|
||||
#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \
|
||||
#define TOR_SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \
|
||||
if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
|
||||
== NULL) \
|
||||
(head)->sqh_last = &(elm)->field.sqe_next; \
|
||||
|
|
@ -324,16 +319,16 @@ struct { \
|
|||
/*
|
||||
* Tail queue definitions.
|
||||
*/
|
||||
#define TAILQ_HEAD(name, type) \
|
||||
#define TOR_TAILQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *tqh_first; /* first element */ \
|
||||
struct type **tqh_last; /* addr of last next element */ \
|
||||
}
|
||||
|
||||
#define TAILQ_HEAD_INITIALIZER(head) \
|
||||
#define TOR_TAILQ_HEAD_INITIALIZER(head) \
|
||||
{ NULL, &(head).tqh_first }
|
||||
|
||||
#define TAILQ_ENTRY(type) \
|
||||
#define TOR_TAILQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *tqe_next; /* next element */ \
|
||||
struct type **tqe_prev; /* address of previous next element */ \
|
||||
|
|
@ -342,49 +337,49 @@ struct { \
|
|||
/*
|
||||
* tail queue access methods
|
||||
*/
|
||||
#define TAILQ_FIRST(head) ((head)->tqh_first)
|
||||
#define TAILQ_END(head) NULL
|
||||
#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
|
||||
#define TAILQ_LAST(head, headname) \
|
||||
#define TOR_TAILQ_FIRST(head) ((head)->tqh_first)
|
||||
#define TOR_TAILQ_END(head) NULL
|
||||
#define TOR_TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
|
||||
#define TOR_TAILQ_LAST(head, headname) \
|
||||
(*(((struct headname *)((head)->tqh_last))->tqh_last))
|
||||
/* XXX */
|
||||
#define TAILQ_PREV(elm, headname, field) \
|
||||
#define TOR_TAILQ_PREV(elm, headname, field) \
|
||||
(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
|
||||
#define TAILQ_EMPTY(head) \
|
||||
(TAILQ_FIRST(head) == TAILQ_END(head))
|
||||
#define TOR_TAILQ_EMPTY(head) \
|
||||
(TOR_TAILQ_FIRST(head) == TOR_TAILQ_END(head))
|
||||
|
||||
#define TAILQ_FOREACH(var, head, field) \
|
||||
for((var) = TAILQ_FIRST(head); \
|
||||
(var) != TAILQ_END(head); \
|
||||
(var) = TAILQ_NEXT(var, field))
|
||||
#define TOR_TAILQ_FOREACH(var, head, field) \
|
||||
for((var) = TOR_TAILQ_FIRST(head); \
|
||||
(var) != TOR_TAILQ_END(head); \
|
||||
(var) = TOR_TAILQ_NEXT(var, field))
|
||||
|
||||
#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TAILQ_FIRST(head); \
|
||||
(var) != TAILQ_END(head) && \
|
||||
((tvar) = TAILQ_NEXT(var, field), 1); \
|
||||
#define TOR_TAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TOR_TAILQ_FIRST(head); \
|
||||
(var) != TOR_TAILQ_END(head) && \
|
||||
((tvar) = TOR_TAILQ_NEXT(var, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
|
||||
#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
|
||||
for((var) = TAILQ_LAST(head, headname); \
|
||||
(var) != TAILQ_END(head); \
|
||||
(var) = TAILQ_PREV(var, headname, field))
|
||||
#define TOR_TAILQ_FOREACH_REVERSE(var, head, headname, field) \
|
||||
for((var) = TOR_TAILQ_LAST(head, headname); \
|
||||
(var) != TOR_TAILQ_END(head); \
|
||||
(var) = TOR_TAILQ_PREV(var, headname, field))
|
||||
|
||||
#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
|
||||
for ((var) = TAILQ_LAST(head, headname); \
|
||||
(var) != TAILQ_END(head) && \
|
||||
((tvar) = TAILQ_PREV(var, headname, field), 1); \
|
||||
#define TOR_TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
|
||||
for ((var) = TOR_TAILQ_LAST(head, headname); \
|
||||
(var) != TOR_TAILQ_END(head) && \
|
||||
((tvar) = TOR_TAILQ_PREV(var, headname, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
/*
|
||||
* Tail queue functions.
|
||||
*/
|
||||
#define TAILQ_INIT(head) do { \
|
||||
#define TOR_TAILQ_INIT(head) do { \
|
||||
(head)->tqh_first = NULL; \
|
||||
(head)->tqh_last = &(head)->tqh_first; \
|
||||
} while (0)
|
||||
|
||||
#define TAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
#define TOR_TAILQ_INSERT_HEAD(head, elm, field) do { \
|
||||
if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
|
||||
(head)->tqh_first->field.tqe_prev = \
|
||||
&(elm)->field.tqe_next; \
|
||||
|
|
@ -394,14 +389,14 @@ struct { \
|
|||
(elm)->field.tqe_prev = &(head)->tqh_first; \
|
||||
} while (0)
|
||||
|
||||
#define TAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
#define TOR_TAILQ_INSERT_TAIL(head, elm, field) do { \
|
||||
(elm)->field.tqe_next = NULL; \
|
||||
(elm)->field.tqe_prev = (head)->tqh_last; \
|
||||
*(head)->tqh_last = (elm); \
|
||||
(head)->tqh_last = &(elm)->field.tqe_next; \
|
||||
} while (0)
|
||||
|
||||
#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
#define TOR_TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
|
||||
(elm)->field.tqe_next->field.tqe_prev = \
|
||||
&(elm)->field.tqe_next; \
|
||||
|
|
@ -411,25 +406,25 @@ struct { \
|
|||
(elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
|
||||
} while (0)
|
||||
|
||||
#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
#define TOR_TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
|
||||
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
|
||||
(elm)->field.tqe_next = (listelm); \
|
||||
*(listelm)->field.tqe_prev = (elm); \
|
||||
(listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
|
||||
} while (0)
|
||||
|
||||
#define TAILQ_REMOVE(head, elm, field) do { \
|
||||
#define TOR_TAILQ_REMOVE(head, elm, field) do { \
|
||||
if (((elm)->field.tqe_next) != NULL) \
|
||||
(elm)->field.tqe_next->field.tqe_prev = \
|
||||
(elm)->field.tqe_prev; \
|
||||
else \
|
||||
(head)->tqh_last = (elm)->field.tqe_prev; \
|
||||
*(elm)->field.tqe_prev = (elm)->field.tqe_next; \
|
||||
_Q_INVALIDATE((elm)->field.tqe_prev); \
|
||||
_Q_INVALIDATE((elm)->field.tqe_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.tqe_prev); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.tqe_next); \
|
||||
} while (0)
|
||||
|
||||
#define TAILQ_REPLACE(head, elm, elm2, field) do { \
|
||||
#define TOR_TAILQ_REPLACE(head, elm, elm2, field) do { \
|
||||
if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \
|
||||
(elm2)->field.tqe_next->field.tqe_prev = \
|
||||
&(elm2)->field.tqe_next; \
|
||||
|
|
@ -437,23 +432,23 @@ struct { \
|
|||
(head)->tqh_last = &(elm2)->field.tqe_next; \
|
||||
(elm2)->field.tqe_prev = (elm)->field.tqe_prev; \
|
||||
*(elm2)->field.tqe_prev = (elm2); \
|
||||
_Q_INVALIDATE((elm)->field.tqe_prev); \
|
||||
_Q_INVALIDATE((elm)->field.tqe_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.tqe_prev); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.tqe_next); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Circular queue definitions.
|
||||
*/
|
||||
#define CIRCLEQ_HEAD(name, type) \
|
||||
#define TOR_CIRCLEQ_HEAD(name, type) \
|
||||
struct name { \
|
||||
struct type *cqh_first; /* first element */ \
|
||||
struct type *cqh_last; /* last element */ \
|
||||
}
|
||||
|
||||
#define CIRCLEQ_HEAD_INITIALIZER(head) \
|
||||
{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
|
||||
#define TOR_CIRCLEQ_HEAD_INITIALIZER(head) \
|
||||
{ TOR_CIRCLEQ_END(&head), TOR_CIRCLEQ_END(&head) }
|
||||
|
||||
#define CIRCLEQ_ENTRY(type) \
|
||||
#define TOR_CIRCLEQ_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *cqe_next; /* next element */ \
|
||||
struct type *cqe_prev; /* previous element */ \
|
||||
|
|
@ -462,112 +457,112 @@ struct { \
|
|||
/*
|
||||
* Circular queue access methods
|
||||
*/
|
||||
#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
|
||||
#define CIRCLEQ_LAST(head) ((head)->cqh_last)
|
||||
#define CIRCLEQ_END(head) ((void *)(head))
|
||||
#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 TOR_CIRCLEQ_FIRST(head) ((head)->cqh_first)
|
||||
#define TOR_CIRCLEQ_LAST(head) ((head)->cqh_last)
|
||||
#define TOR_CIRCLEQ_END(head) ((void *)(head))
|
||||
#define TOR_CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
|
||||
#define TOR_CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
|
||||
#define TOR_CIRCLEQ_EMPTY(head) \
|
||||
(TOR_CIRCLEQ_FIRST(head) == TOR_CIRCLEQ_END(head))
|
||||
|
||||
#define CIRCLEQ_FOREACH(var, head, field) \
|
||||
for((var) = CIRCLEQ_FIRST(head); \
|
||||
(var) != CIRCLEQ_END(head); \
|
||||
(var) = CIRCLEQ_NEXT(var, field))
|
||||
#define TOR_CIRCLEQ_FOREACH(var, head, field) \
|
||||
for((var) = TOR_CIRCLEQ_FIRST(head); \
|
||||
(var) != TOR_CIRCLEQ_END(head); \
|
||||
(var) = TOR_CIRCLEQ_NEXT(var, field))
|
||||
|
||||
#define CIRCLEQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = CIRCLEQ_FIRST(head); \
|
||||
(var) != CIRCLEQ_END(head) && \
|
||||
((tvar) = CIRCLEQ_NEXT(var, field), 1); \
|
||||
#define TOR_CIRCLEQ_FOREACH_SAFE(var, head, field, tvar) \
|
||||
for ((var) = TOR_CIRCLEQ_FIRST(head); \
|
||||
(var) != TOR_CIRCLEQ_END(head) && \
|
||||
((tvar) = TOR_CIRCLEQ_NEXT(var, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
|
||||
for((var) = CIRCLEQ_LAST(head); \
|
||||
(var) != CIRCLEQ_END(head); \
|
||||
(var) = CIRCLEQ_PREV(var, field))
|
||||
#define TOR_CIRCLEQ_FOREACH_REVERSE(var, head, field) \
|
||||
for((var) = TOR_CIRCLEQ_LAST(head); \
|
||||
(var) != TOR_CIRCLEQ_END(head); \
|
||||
(var) = TOR_CIRCLEQ_PREV(var, field))
|
||||
|
||||
#define CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
|
||||
for ((var) = CIRCLEQ_LAST(head, headname); \
|
||||
(var) != CIRCLEQ_END(head) && \
|
||||
((tvar) = CIRCLEQ_PREV(var, headname, field), 1); \
|
||||
#define TOR_CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
|
||||
for ((var) = TOR_CIRCLEQ_LAST(head, headname); \
|
||||
(var) != TOR_CIRCLEQ_END(head) && \
|
||||
((tvar) = TOR_CIRCLEQ_PREV(var, headname, field), 1); \
|
||||
(var) = (tvar))
|
||||
|
||||
/*
|
||||
* Circular queue functions.
|
||||
*/
|
||||
#define CIRCLEQ_INIT(head) do { \
|
||||
(head)->cqh_first = CIRCLEQ_END(head); \
|
||||
(head)->cqh_last = CIRCLEQ_END(head); \
|
||||
#define TOR_CIRCLEQ_INIT(head) do { \
|
||||
(head)->cqh_first = TOR_CIRCLEQ_END(head); \
|
||||
(head)->cqh_last = TOR_CIRCLEQ_END(head); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
#define TOR_CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
|
||||
(elm)->field.cqe_next = (listelm)->field.cqe_next; \
|
||||
(elm)->field.cqe_prev = (listelm); \
|
||||
if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \
|
||||
if ((listelm)->field.cqe_next == TOR_CIRCLEQ_END(head)) \
|
||||
(head)->cqh_last = (elm); \
|
||||
else \
|
||||
(listelm)->field.cqe_next->field.cqe_prev = (elm); \
|
||||
(listelm)->field.cqe_next = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
|
||||
#define TOR_CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
|
||||
(elm)->field.cqe_next = (listelm); \
|
||||
(elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
|
||||
if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \
|
||||
if ((listelm)->field.cqe_prev == TOR_CIRCLEQ_END(head)) \
|
||||
(head)->cqh_first = (elm); \
|
||||
else \
|
||||
(listelm)->field.cqe_prev->field.cqe_next = (elm); \
|
||||
(listelm)->field.cqe_prev = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
#define TOR_CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
|
||||
(elm)->field.cqe_next = (head)->cqh_first; \
|
||||
(elm)->field.cqe_prev = CIRCLEQ_END(head); \
|
||||
if ((head)->cqh_last == CIRCLEQ_END(head)) \
|
||||
(elm)->field.cqe_prev = TOR_CIRCLEQ_END(head); \
|
||||
if ((head)->cqh_last == TOR_CIRCLEQ_END(head)) \
|
||||
(head)->cqh_last = (elm); \
|
||||
else \
|
||||
(head)->cqh_first->field.cqe_prev = (elm); \
|
||||
(head)->cqh_first = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
(elm)->field.cqe_next = CIRCLEQ_END(head); \
|
||||
#define TOR_CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
|
||||
(elm)->field.cqe_next = TOR_CIRCLEQ_END(head); \
|
||||
(elm)->field.cqe_prev = (head)->cqh_last; \
|
||||
if ((head)->cqh_first == CIRCLEQ_END(head)) \
|
||||
if ((head)->cqh_first == TOR_CIRCLEQ_END(head)) \
|
||||
(head)->cqh_first = (elm); \
|
||||
else \
|
||||
(head)->cqh_last->field.cqe_next = (elm); \
|
||||
(head)->cqh_last = (elm); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_REMOVE(head, elm, field) do { \
|
||||
if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \
|
||||
#define TOR_CIRCLEQ_REMOVE(head, elm, field) do { \
|
||||
if ((elm)->field.cqe_next == TOR_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)) \
|
||||
if ((elm)->field.cqe_prev == TOR_CIRCLEQ_END(head)) \
|
||||
(head)->cqh_first = (elm)->field.cqe_next; \
|
||||
else \
|
||||
(elm)->field.cqe_prev->field.cqe_next = \
|
||||
(elm)->field.cqe_next; \
|
||||
_Q_INVALIDATE((elm)->field.cqe_prev); \
|
||||
_Q_INVALIDATE((elm)->field.cqe_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.cqe_prev); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.cqe_next); \
|
||||
} while (0)
|
||||
|
||||
#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \
|
||||
#define TOR_CIRCLEQ_REPLACE(head, elm, elm2, field) do { \
|
||||
if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \
|
||||
CIRCLEQ_END(head)) \
|
||||
TOR_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)) \
|
||||
TOR_CIRCLEQ_END(head)) \
|
||||
(head).cqh_first = (elm2); \
|
||||
else \
|
||||
(elm2)->field.cqe_prev->field.cqe_next = (elm2); \
|
||||
_Q_INVALIDATE((elm)->field.cqe_prev); \
|
||||
_Q_INVALIDATE((elm)->field.cqe_next); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.cqe_prev); \
|
||||
TOR_Q_INVALIDATE_((elm)->field.cqe_next); \
|
||||
} while (0)
|
||||
|
||||
#endif /* !_SYS_QUEUE_H_ */
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
|
||||
typedef struct cell_queue_entry_s cell_queue_entry_t;
|
||||
struct cell_queue_entry_s {
|
||||
SIMPLEQ_ENTRY(cell_queue_entry_s) next;
|
||||
TOR_SIMPLEQ_ENTRY(cell_queue_entry_s) next;
|
||||
enum {
|
||||
CELL_QUEUE_FIXED,
|
||||
CELL_QUEUE_VAR,
|
||||
|
|
@ -89,7 +89,7 @@ HT_HEAD(channel_idmap, channel_idmap_entry_s) channel_identity_map =
|
|||
typedef struct channel_idmap_entry_s {
|
||||
HT_ENTRY(channel_idmap_entry_s) node;
|
||||
uint8_t digest[DIGEST_LEN];
|
||||
LIST_HEAD(channel_list_s, channel_s) channel_list;
|
||||
TOR_LIST_HEAD(channel_list_s, channel_s) channel_list;
|
||||
} channel_idmap_entry_t;
|
||||
|
||||
static INLINE unsigned
|
||||
|
|
@ -554,10 +554,10 @@ channel_add_to_digest_map(channel_t *chan)
|
|||
if (! ent) {
|
||||
ent = tor_malloc(sizeof(channel_idmap_entry_t));
|
||||
memcpy(ent->digest, chan->identity_digest, DIGEST_LEN);
|
||||
LIST_INIT(&ent->channel_list);
|
||||
TOR_LIST_INIT(&ent->channel_list);
|
||||
HT_INSERT(channel_idmap, &channel_identity_map, ent);
|
||||
}
|
||||
LIST_INSERT_HEAD(&ent->channel_list, chan, next_with_same_id);
|
||||
TOR_LIST_INSERT_HEAD(&ent->channel_list, chan, next_with_same_id);
|
||||
|
||||
log_debug(LD_CHANNEL,
|
||||
"Added channel %p (global ID " U64_FORMAT ") "
|
||||
|
|
@ -612,7 +612,7 @@ channel_remove_from_digest_map(channel_t *chan)
|
|||
#endif
|
||||
|
||||
/* Pull it out of its list, wherever that list is */
|
||||
LIST_REMOVE(chan, next_with_same_id);
|
||||
TOR_LIST_REMOVE(chan, next_with_same_id);
|
||||
|
||||
memcpy(search.digest, chan->identity_digest, DIGEST_LEN);
|
||||
ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
|
||||
|
|
@ -621,7 +621,7 @@ channel_remove_from_digest_map(channel_t *chan)
|
|||
if (ent) {
|
||||
/* Okay, it's here */
|
||||
|
||||
if (LIST_EMPTY(&ent->channel_list)) {
|
||||
if (TOR_LIST_EMPTY(&ent->channel_list)) {
|
||||
HT_REMOVE(channel_idmap, &channel_identity_map, ent);
|
||||
tor_free(ent);
|
||||
}
|
||||
|
|
@ -691,7 +691,7 @@ channel_find_by_remote_digest(const char *identity_digest)
|
|||
memcpy(search.digest, identity_digest, DIGEST_LEN);
|
||||
ent = HT_FIND(channel_idmap, &channel_identity_map, &search);
|
||||
if (ent) {
|
||||
rv = LIST_FIRST(&ent->channel_list);
|
||||
rv = TOR_LIST_FIRST(&ent->channel_list);
|
||||
}
|
||||
|
||||
return rv;
|
||||
|
|
@ -709,7 +709,7 @@ channel_next_with_digest(channel_t *chan)
|
|||
{
|
||||
tor_assert(chan);
|
||||
|
||||
return LIST_NEXT(chan, next_with_same_id);
|
||||
return TOR_LIST_NEXT(chan, next_with_same_id);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -735,8 +735,8 @@ channel_init(channel_t *chan)
|
|||
chan->next_circ_id = crypto_rand_int(1 << 15);
|
||||
|
||||
/* Initialize queues. */
|
||||
SIMPLEQ_INIT(&chan->incoming_queue);
|
||||
SIMPLEQ_INIT(&chan->outgoing_queue);
|
||||
TOR_SIMPLEQ_INIT(&chan->incoming_queue);
|
||||
TOR_SIMPLEQ_INIT(&chan->outgoing_queue);
|
||||
|
||||
/* Initialize list entries. */
|
||||
memset(&chan->next_with_same_id, 0, sizeof(chan->next_with_same_id));
|
||||
|
|
@ -879,16 +879,16 @@ channel_force_free(channel_t *chan)
|
|||
}
|
||||
|
||||
/* We might still have a cell queue; kill it */
|
||||
SIMPLEQ_FOREACH_SAFE(cell, &chan->incoming_queue, next, cell_tmp) {
|
||||
TOR_SIMPLEQ_FOREACH_SAFE(cell, &chan->incoming_queue, next, cell_tmp) {
|
||||
cell_queue_entry_free(cell, 0);
|
||||
}
|
||||
SIMPLEQ_INIT(&chan->incoming_queue);
|
||||
TOR_SIMPLEQ_INIT(&chan->incoming_queue);
|
||||
|
||||
/* Outgoing cell queue is similar, but we can have to free packed cells */
|
||||
SIMPLEQ_FOREACH_SAFE(cell, &chan->outgoing_queue, next, cell_tmp) {
|
||||
TOR_SIMPLEQ_FOREACH_SAFE(cell, &chan->outgoing_queue, next, cell_tmp) {
|
||||
cell_queue_entry_free(cell, 0);
|
||||
}
|
||||
SIMPLEQ_INIT(&chan->outgoing_queue);
|
||||
TOR_SIMPLEQ_INIT(&chan->outgoing_queue);
|
||||
|
||||
tor_free(chan);
|
||||
}
|
||||
|
|
@ -1051,7 +1051,7 @@ channel_set_cell_handlers(channel_t *chan,
|
|||
chan->var_cell_handler = var_cell_handler;
|
||||
|
||||
/* Re-run the queue if we have one and there's any reason to */
|
||||
if (! SIMPLEQ_EMPTY(&chan->incoming_queue) &&
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->incoming_queue) &&
|
||||
try_again &&
|
||||
(chan->cell_handler ||
|
||||
chan->var_cell_handler)) channel_process_cells(chan);
|
||||
|
|
@ -1686,7 +1686,7 @@ channel_write_cell_queue_entry(channel_t *chan, cell_queue_entry_t *q)
|
|||
}
|
||||
|
||||
/* Can we send it right out? If so, try */
|
||||
if (SIMPLEQ_EMPTY(&chan->outgoing_queue) &&
|
||||
if (TOR_SIMPLEQ_EMPTY(&chan->outgoing_queue) &&
|
||||
chan->state == CHANNEL_STATE_OPEN) {
|
||||
/* Pick the right write function for this cell type and save the result */
|
||||
switch (q->type) {
|
||||
|
|
@ -1728,7 +1728,7 @@ channel_write_cell_queue_entry(channel_t *chan, cell_queue_entry_t *q)
|
|||
* used the stack.
|
||||
*/
|
||||
tmp = cell_queue_entry_dup(q);
|
||||
SIMPLEQ_INSERT_TAIL(&chan->outgoing_queue, tmp, next);
|
||||
TOR_SIMPLEQ_INSERT_TAIL(&chan->outgoing_queue, tmp, next);
|
||||
/* Try to process the queue? */
|
||||
if (chan->state == CHANNEL_STATE_OPEN) channel_flush_cells(chan);
|
||||
}
|
||||
|
|
@ -1914,15 +1914,15 @@ channel_change_state(channel_t *chan, channel_state_t to_state)
|
|||
channel_do_open_actions(chan);
|
||||
|
||||
/* Check for queued cells to process */
|
||||
if (! SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
channel_process_cells(chan);
|
||||
if (! SIMPLEQ_EMPTY(&chan->outgoing_queue))
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->outgoing_queue))
|
||||
channel_flush_cells(chan);
|
||||
} else if (to_state == CHANNEL_STATE_CLOSED ||
|
||||
to_state == CHANNEL_STATE_ERROR) {
|
||||
/* Assert that all queues are empty */
|
||||
tor_assert(SIMPLEQ_EMPTY(&chan->incoming_queue));
|
||||
tor_assert(SIMPLEQ_EMPTY(&chan->outgoing_queue));
|
||||
tor_assert(TOR_SIMPLEQ_EMPTY(&chan->incoming_queue));
|
||||
tor_assert(TOR_SIMPLEQ_EMPTY(&chan->outgoing_queue));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2096,7 +2096,7 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan,
|
|||
/* If we aren't in CHANNEL_STATE_OPEN, nothing goes through */
|
||||
if (chan->state == CHANNEL_STATE_OPEN) {
|
||||
while ((unlimited || num_cells > flushed) &&
|
||||
NULL != (q = SIMPLEQ_FIRST(&chan->outgoing_queue))) {
|
||||
NULL != (q = TOR_SIMPLEQ_FIRST(&chan->outgoing_queue))) {
|
||||
|
||||
if (1) {
|
||||
/*
|
||||
|
|
@ -2185,7 +2185,7 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan,
|
|||
}
|
||||
|
||||
/* if q got NULLed out, we used it and should remove the queue entry */
|
||||
if (!q) SIMPLEQ_REMOVE_HEAD(&chan->outgoing_queue, next);
|
||||
if (!q) TOR_SIMPLEQ_REMOVE_HEAD(&chan->outgoing_queue, next);
|
||||
/* No cell removed from list, so we can't go on any further */
|
||||
else break;
|
||||
}
|
||||
|
|
@ -2193,7 +2193,7 @@ channel_flush_some_cells_from_outgoing_queue(channel_t *chan,
|
|||
}
|
||||
|
||||
/* Did we drain the queue? */
|
||||
if (SIMPLEQ_EMPTY(&chan->outgoing_queue)) {
|
||||
if (TOR_SIMPLEQ_EMPTY(&chan->outgoing_queue)) {
|
||||
channel_timestamp_drained(chan);
|
||||
}
|
||||
|
||||
|
|
@ -2227,7 +2227,7 @@ channel_more_to_flush(channel_t *chan)
|
|||
tor_assert(chan);
|
||||
|
||||
/* Check if we have any queued */
|
||||
if (! SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
return 1;
|
||||
|
||||
/* Check if any circuits would like to queue some */
|
||||
|
|
@ -2435,13 +2435,13 @@ channel_process_cells(channel_t *chan)
|
|||
if (!(chan->cell_handler ||
|
||||
chan->var_cell_handler)) return;
|
||||
/* Nothing we can do if we have no cells */
|
||||
if (SIMPLEQ_EMPTY(&chan->incoming_queue)) return;
|
||||
if (TOR_SIMPLEQ_EMPTY(&chan->incoming_queue)) return;
|
||||
|
||||
/*
|
||||
* Process cells until we're done or find one we have no current handler
|
||||
* for.
|
||||
*/
|
||||
while (NULL != (q = SIMPLEQ_FIRST(&chan->incoming_queue))) {
|
||||
while (NULL != (q = TOR_SIMPLEQ_FIRST(&chan->incoming_queue))) {
|
||||
tor_assert(q);
|
||||
tor_assert(q->type == CELL_QUEUE_FIXED ||
|
||||
q->type == CELL_QUEUE_VAR);
|
||||
|
|
@ -2449,7 +2449,7 @@ channel_process_cells(channel_t *chan)
|
|||
if (q->type == CELL_QUEUE_FIXED &&
|
||||
chan->cell_handler) {
|
||||
/* Handle a fixed-length cell */
|
||||
SIMPLEQ_REMOVE_HEAD(&chan->incoming_queue, next);
|
||||
TOR_SIMPLEQ_REMOVE_HEAD(&chan->incoming_queue, next);
|
||||
tor_assert(q->u.fixed.cell);
|
||||
log_debug(LD_CHANNEL,
|
||||
"Processing incoming cell_t %p for channel %p (global ID "
|
||||
|
|
@ -2461,7 +2461,7 @@ channel_process_cells(channel_t *chan)
|
|||
} else if (q->type == CELL_QUEUE_VAR &&
|
||||
chan->var_cell_handler) {
|
||||
/* Handle a variable-length cell */
|
||||
SIMPLEQ_REMOVE_HEAD(&chan->incoming_queue, next);
|
||||
TOR_SIMPLEQ_REMOVE_HEAD(&chan->incoming_queue, next);
|
||||
tor_assert(q->u.var.var_cell);
|
||||
log_debug(LD_CHANNEL,
|
||||
"Processing incoming var_cell_t %p for channel %p (global ID "
|
||||
|
|
@ -2496,7 +2496,7 @@ channel_queue_cell(channel_t *chan, cell_t *cell)
|
|||
|
||||
/* Do we need to queue it, or can we just call the handler right away? */
|
||||
if (!(chan->cell_handler)) need_to_queue = 1;
|
||||
if (! SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
need_to_queue = 1;
|
||||
|
||||
/* Timestamp for receiving */
|
||||
|
|
@ -2522,7 +2522,7 @@ channel_queue_cell(channel_t *chan, cell_t *cell)
|
|||
"(global ID " U64_FORMAT ")",
|
||||
cell, chan,
|
||||
U64_PRINTF_ARG(chan->global_identifier));
|
||||
SIMPLEQ_INSERT_TAIL(&chan->incoming_queue, q, next);
|
||||
TOR_SIMPLEQ_INSERT_TAIL(&chan->incoming_queue, q, next);
|
||||
if (chan->cell_handler ||
|
||||
chan->var_cell_handler) {
|
||||
channel_process_cells(chan);
|
||||
|
|
@ -2549,7 +2549,7 @@ channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell)
|
|||
|
||||
/* Do we need to queue it, or can we just call the handler right away? */
|
||||
if (!(chan->var_cell_handler)) need_to_queue = 1;
|
||||
if (! SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->incoming_queue))
|
||||
need_to_queue = 1;
|
||||
|
||||
/* Timestamp for receiving */
|
||||
|
|
@ -2575,7 +2575,7 @@ channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell)
|
|||
"(global ID " U64_FORMAT ")",
|
||||
var_cell, chan,
|
||||
U64_PRINTF_ARG(chan->global_identifier));
|
||||
SIMPLEQ_INSERT_TAIL(&chan->incoming_queue, q, next);
|
||||
TOR_SIMPLEQ_INSERT_TAIL(&chan->incoming_queue, q, next);
|
||||
if (chan->cell_handler ||
|
||||
chan->var_cell_handler) {
|
||||
channel_process_cells(chan);
|
||||
|
|
@ -3115,7 +3115,7 @@ chan_cell_queue_len(const chan_cell_queue_t *queue)
|
|||
{
|
||||
int r = 0;
|
||||
cell_queue_entry_t *cell;
|
||||
SIMPLEQ_FOREACH(cell, queue, next)
|
||||
TOR_SIMPLEQ_FOREACH(cell, queue, next)
|
||||
++r;
|
||||
return r;
|
||||
}
|
||||
|
|
@ -3504,7 +3504,7 @@ channel_has_queued_writes(channel_t *chan)
|
|||
tor_assert(chan);
|
||||
tor_assert(chan->has_queued_writes);
|
||||
|
||||
if (! SIMPLEQ_EMPTY(&chan->outgoing_queue)) {
|
||||
if (! TOR_SIMPLEQ_EMPTY(&chan->outgoing_queue)) {
|
||||
has_writes = 1;
|
||||
} else {
|
||||
/* Check with the lower layer */
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ typedef void (*channel_cell_handler_fn_ptr)(channel_t *, cell_t *);
|
|||
typedef void (*channel_var_cell_handler_fn_ptr)(channel_t *, var_cell_t *);
|
||||
|
||||
struct cell_queue_entry_s;
|
||||
SIMPLEQ_HEAD(chan_cell_queue, cell_queue_entry_s) incoming_queue;
|
||||
TOR_SIMPLEQ_HEAD(chan_cell_queue, cell_queue_entry_s) incoming_queue;
|
||||
typedef struct chan_cell_queue chan_cell_queue_t;
|
||||
|
||||
/*
|
||||
|
|
@ -125,7 +125,7 @@ struct channel_s {
|
|||
* Linked list of channels with the same identity digest, for the
|
||||
* digest->channel map
|
||||
*/
|
||||
LIST_ENTRY(channel_s) next_with_same_id;
|
||||
TOR_LIST_ENTRY(channel_s) next_with_same_id;
|
||||
|
||||
/* List of incoming cells to handle */
|
||||
chan_cell_queue_t incoming_queue;
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@
|
|||
/** Type for a linked list of circuits that are waiting for a free CPU worker
|
||||
* to process a waiting onion handshake. */
|
||||
typedef struct onion_queue_t {
|
||||
TAILQ_ENTRY(onion_queue_t) next;
|
||||
TOR_TAILQ_ENTRY(onion_queue_t) next;
|
||||
or_circuit_t *circ;
|
||||
create_cell_t *onionskin;
|
||||
time_t when_added;
|
||||
|
|
@ -36,8 +36,8 @@ typedef struct onion_queue_t {
|
|||
#define ONIONQUEUE_WAIT_CUTOFF 5
|
||||
|
||||
/** Queue of circuits waiting for CPU workers, or NULL if the list is empty.*/
|
||||
TAILQ_HEAD(onion_queue_head_t, onion_queue_t) ol_list =
|
||||
TAILQ_HEAD_INITIALIZER(ol_list);
|
||||
TOR_TAILQ_HEAD(onion_queue_head_t, onion_queue_t) ol_list =
|
||||
TOR_TAILQ_HEAD_INITIALIZER(ol_list);
|
||||
|
||||
/** Number of entries of each type currently in ol_list. */
|
||||
static int ol_entries[MAX_ONION_HANDSHAKE_TYPE+1];
|
||||
|
|
@ -120,11 +120,11 @@ onion_pending_add(or_circuit_t *circ, create_cell_t *onionskin)
|
|||
|
||||
++ol_entries[onionskin->handshake_type];
|
||||
circ->onionqueue_entry = tmp;
|
||||
TAILQ_INSERT_TAIL(&ol_list, tmp, next);
|
||||
TOR_TAILQ_INSERT_TAIL(&ol_list, tmp, next);
|
||||
|
||||
/* cull elderly requests. */
|
||||
while (1) {
|
||||
onion_queue_t *head = TAILQ_FIRST(&ol_list);
|
||||
onion_queue_t *head = TOR_TAILQ_FIRST(&ol_list);
|
||||
if (now - head->when_added < (time_t)ONIONQUEUE_WAIT_CUTOFF)
|
||||
break;
|
||||
|
||||
|
|
@ -145,7 +145,7 @@ or_circuit_t *
|
|||
onion_next_task(create_cell_t **onionskin_out)
|
||||
{
|
||||
or_circuit_t *circ;
|
||||
onion_queue_t *head = TAILQ_FIRST(&ol_list);
|
||||
onion_queue_t *head = TOR_TAILQ_FIRST(&ol_list);
|
||||
|
||||
if (!head)
|
||||
return NULL; /* no onions pending, we're done */
|
||||
|
|
@ -184,7 +184,7 @@ onion_pending_remove(or_circuit_t *circ)
|
|||
static void
|
||||
onion_queue_entry_remove(onion_queue_t *victim)
|
||||
{
|
||||
TAILQ_REMOVE(&ol_list, victim, next);
|
||||
TOR_TAILQ_REMOVE(&ol_list, victim, next);
|
||||
|
||||
if (victim->circ)
|
||||
victim->circ->onionqueue_entry = NULL;
|
||||
|
|
@ -202,7 +202,7 @@ void
|
|||
clear_pending_onions(void)
|
||||
{
|
||||
onion_queue_t *victim;
|
||||
while ((victim = TAILQ_FIRST(&ol_list))) {
|
||||
while ((victim = TOR_TAILQ_FIRST(&ol_list))) {
|
||||
onion_queue_entry_remove(victim);
|
||||
}
|
||||
memset(ol_entries, 0, sizeof(ol_entries));
|
||||
|
|
|
|||
Loading…
Reference in New Issue