commit 35daf6f6029c3285b260f9a3f4287b2fa063c3eb
Author: Nick Mathewson <nickm(a)torproject.org>
Date: Wed Jan 30 12:27:19 2013 -0500
Rename all of the macros in tor_queue.h to start with TOR_
---
changes/rename_queue_macros | 6 +
src/ext/README | 4 +-
src/ext/tor_queue.h | 341 +++++++++++++++++++++----------------------
src/or/channel.c | 70 +++++-----
src/or/channel.h | 4 +-
src/or/onion.c | 16 +-
6 files changed, 222 insertions(+), 219 deletions(-)
diff --git a/changes/rename_queue_macros b/changes/rename_queue_macros
new file mode 100644
index 0000000..29373ac
--- /dev/null
+++ b/changes/rename_queue_macros
@@ -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.
+
diff --git a/src/ext/README b/src/ext/README
index cd23f29..58ba7f6 100644
--- a/src/ext/README
+++ b/src/ext/README
@@ -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
diff --git a/src/ext/tor_queue.h b/src/ext/tor_queue.h
index 595e4a3..f05e48c 100644
--- a/src/ext/tor_queue.h
+++ b/src/ext/tor_queue.h
@@ -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 SLIST_FOREACH(var, head, field) \
- for((var) = SLIST_FIRST(head); \
- (var) != SLIST_END(head); \
- (var) = 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_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 TOR_SLIST_FOREACH(var, head, field) \
+ for((var) = TOR_SLIST_FIRST(head); \
+ (var) != TOR_SLIST_END(head); \
+ (var) = TOR_SLIST_NEXT(var, field))
+
+#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 LIST_FOREACH(var, head, field) \
- for((var) = LIST_FIRST(head); \
- (var)!= LIST_END(head); \
- (var) = 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_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 TOR_LIST_FOREACH(var, head, field) \
+ for((var) = TOR_LIST_FIRST(head); \
+ (var)!= TOR_LIST_END(head); \
+ (var) = TOR_LIST_NEXT(var, field))
+
+#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 SIMPLEQ_FOREACH(var, head, field) \
- for((var) = SIMPLEQ_FIRST(head); \
- (var) != SIMPLEQ_END(head); \
- (var) = 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_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 TOR_SIMPLEQ_FOREACH(var, head, field) \
+ for((var) = TOR_SIMPLEQ_FIRST(head); \
+ (var) != TOR_SIMPLEQ_END(head); \
+ (var) = TOR_SIMPLEQ_NEXT(var, field))
+
+#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 TAILQ_FOREACH(var, head, field) \
- for((var) = TAILQ_FIRST(head); \
- (var) != TAILQ_END(head); \
- (var) = 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_EMPTY(head) \
+ (TOR_TAILQ_FIRST(head) == TOR_TAILQ_END(head))
+
+#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 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 CIRCLEQ_FOREACH(var, head, field) \
- for((var) = CIRCLEQ_FIRST(head); \
- (var) != CIRCLEQ_END(head); \
- (var) = 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_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 TOR_CIRCLEQ_FOREACH(var, head, field) \
+ for((var) = TOR_CIRCLEQ_FIRST(head); \
+ (var) != TOR_CIRCLEQ_END(head); \
+ (var) = TOR_CIRCLEQ_NEXT(var, field))
+
+#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_ */
diff --git a/src/or/channel.c b/src/or/channel.c
index 7781622..b30e548 100644
--- a/src/or/channel.c
+++ b/src/or/channel.c
@@ -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 */
diff --git a/src/or/channel.h b/src/or/channel.h
index 31bd519..ec79888 100644
--- a/src/or/channel.h
+++ b/src/or/channel.h
@@ -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;
diff --git a/src/or/onion.c b/src/or/onion.c
index e4cdea6..b9f5aa6 100644
--- a/src/or/onion.c
+++ b/src/or/onion.c
@@ -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));
