Rename all of the macros in tor_queue.h to start with TOR_

5 files changed, 216 insertions, 219 deletions

diff --git a/src/ext/README b/src/ext/README
index cd23f2949..58ba7f699 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 595e4a342..f05e48c18 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 778162297..b30e5483c 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 31bd51947..ec7988806 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 e4cdea6bb..b9f5aa6c7 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));