diff options
Diffstat (limited to 'package/ulogd/patches/autotools.patch')
| -rw-r--r-- | package/ulogd/patches/autotools.patch | 734 |
1 files changed, 0 insertions, 734 deletions
diff --git a/package/ulogd/patches/autotools.patch b/package/ulogd/patches/autotools.patch deleted file mode 100644 index 32df817d4..000000000 --- a/package/ulogd/patches/autotools.patch +++ /dev/null @@ -1,734 +0,0 @@ -diff -Nur ulogd-2.0.2.orig/config.h.in ulogd-2.0.2/config.h.in ---- ulogd-2.0.2.orig/config.h.in 2013-03-03 22:19:17.000000000 +0100 -+++ ulogd-2.0.2/config.h.in 2013-10-05 21:13:00.000000000 +0200 -@@ -66,6 +66,9 @@ - */ - #undef HAVE_SYS_NDIR_H - -+/* Define to 1 if you have the <sys/queue.h> header file. */ -+#undef HAVE_SYS_QUEUE_H -+ - /* Define to 1 if you have the <sys/stat.h> header file. */ - #undef HAVE_SYS_STAT_H - -diff -Nur ulogd-2.0.2.orig/configure ulogd-2.0.2/configure ---- ulogd-2.0.2.orig/configure 2013-03-03 22:19:16.000000000 +0100 -+++ ulogd-2.0.2/configure 2013-10-05 21:12:59.000000000 +0200 -@@ -12812,7 +12812,7 @@ - - fi - --for ac_header in fcntl.h unistd.h -+for ac_header in fcntl.h unistd.h sys/queue.h - do : - as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` - ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" -diff -Nur ulogd-2.0.2.orig/configure.ac ulogd-2.0.2/configure.ac ---- ulogd-2.0.2.orig/configure.ac 2013-03-01 16:45:23.000000000 +0100 -+++ ulogd-2.0.2/configure.ac 2013-10-05 21:12:01.000000000 +0200 -@@ -32,7 +32,7 @@ - dnl Checks for header files. - AC_HEADER_DIRENT - AC_HEADER_STDC --AC_CHECK_HEADERS(fcntl.h unistd.h) -+AC_CHECK_HEADERS(fcntl.h unistd.h sys/queue.h) - - dnl Checks for typedefs, structures, and compiler characteristics. - AC_C_CONST -diff -Nur ulogd-2.0.2.orig/filter/raw2packet/ulogd_raw2packet_BASE.c ulogd-2.0.2/filter/raw2packet/ulogd_raw2packet_BASE.c ---- ulogd-2.0.2.orig/filter/raw2packet/ulogd_raw2packet_BASE.c 2013-03-01 16:44:22.000000000 +0100 -+++ ulogd-2.0.2/filter/raw2packet/ulogd_raw2packet_BASE.c 2013-10-05 21:12:39.000000000 +0200 -@@ -588,10 +588,10 @@ - - /* Section 3.1. SCTP Common Header Format */ - typedef struct sctphdr { -- __be16 source; -- __be16 dest; -- __be32 vtag; -- __be32 checksum; -+ uint16_t source; -+ uint16_t dest; -+ uint32_t vtag; -+ uint32_t checksum; - } __attribute__((packed)) sctp_sctphdr_t; - - static int _interp_sctp(struct ulogd_pluginstance *pi, struct sctphdr *sctph, -diff -Nur ulogd-2.0.2.orig/include/linux/tcp.h ulogd-2.0.2/include/linux/tcp.h ---- ulogd-2.0.2.orig/include/linux/tcp.h 1970-01-01 01:00:00.000000000 +0100 -+++ ulogd-2.0.2/include/linux/tcp.h 2013-10-05 21:01:46.000000000 +0200 -@@ -0,0 +1,34 @@ -+struct tcphdr -+ { -+ u_int16_t source; -+ u_int16_t dest; -+ u_int32_t seq; -+ u_int32_t ack_seq; -+# if __BYTE_ORDER == __LITTLE_ENDIAN -+ u_int16_t res1:4; -+ u_int16_t doff:4; -+ u_int16_t fin:1; -+ u_int16_t syn:1; -+ u_int16_t rst:1; -+ u_int16_t psh:1; -+ u_int16_t ack:1; -+ u_int16_t urg:1; -+ u_int16_t res2:2; -+# elif __BYTE_ORDER == __BIG_ENDIAN -+ u_int16_t doff:4; -+ u_int16_t res1:4; -+ u_int16_t res2:2; -+ u_int16_t urg:1; -+ u_int16_t ack:1; -+ u_int16_t psh:1; -+ u_int16_t rst:1; -+ u_int16_t syn:1; -+ u_int16_t fin:1; -+# else -+# error "Adjust your <bits/endian.h> defines" -+# endif -+ u_int16_t window; -+ u_int16_t check; -+ u_int16_t urg_ptr; -+}; -+ -diff -Nur ulogd-2.0.2.orig/output/sqlite3/queue.h ulogd-2.0.2/output/sqlite3/queue.h ---- ulogd-2.0.2.orig/output/sqlite3/queue.h 1970-01-01 01:00:00.000000000 +0100 -+++ ulogd-2.0.2/output/sqlite3/queue.h 2013-10-05 21:01:46.000000000 +0200 -@@ -0,0 +1,574 @@ -+/* -+ * Copyright (c) 1991, 1993 -+ * The Regents of the University of California. All rights reserved. -+ * -+ * Redistribution and use in source and binary forms, with or without -+ * modification, are permitted provided that the following conditions -+ * are met: -+ * 1. Redistributions of source code must retain the above copyright -+ * notice, this list of conditions and the following disclaimer. -+ * 2. Redistributions in binary form must reproduce the above copyright -+ * notice, this list of conditions and the following disclaimer in the -+ * documentation and/or other materials provided with the distribution. -+ * 3. Neither the name of the University nor the names of its contributors -+ * may be used to endorse or promote products derived from this software -+ * without specific prior written permission. -+ * -+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND -+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE -+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS -+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -+ * SUCH DAMAGE. -+ * -+ * @(#)queue.h 8.5 (Berkeley) 8/20/94 -+ */ -+ -+#ifndef _SYS_QUEUE_H_ -+#define _SYS_QUEUE_H_ -+ -+/* -+ * This file defines five types of data structures: singly-linked lists, -+ * lists, simple queues, tail queues, and circular queues. -+ * -+ * A singly-linked list is headed by a single forward pointer. The -+ * elements are singly linked for minimum space and pointer manipulation -+ * overhead at the expense of O(n) removal for arbitrary elements. New -+ * elements can be added to the list after an existing element or at the -+ * head of the list. Elements being removed from the head of the list -+ * should use the explicit macro for this purpose for optimum -+ * efficiency. A singly-linked list may only be traversed in the forward -+ * direction. Singly-linked lists are ideal for applications with large -+ * datasets and few or no removals or for implementing a LIFO queue. -+ * -+ * A list is headed by a single forward pointer (or an array of forward -+ * pointers for a hash table header). The elements are doubly linked -+ * so that an arbitrary element can be removed without a need to -+ * traverse the list. New elements can be added to the list before -+ * or after an existing element or at the head of the list. A list -+ * may only be traversed in the forward direction. -+ * -+ * A simple queue is headed by a pair of pointers, one the head of the -+ * list and the other to the tail of the list. The elements are singly -+ * linked to save space, so elements can only be removed from the -+ * head of the list. New elements can be added to the list after -+ * an existing element, at the head of the list, or at the end of the -+ * list. A simple queue may only be traversed in the forward direction. -+ * -+ * A tail queue is headed by a pair of pointers, one to the head of the -+ * list and the other to the tail of the list. The elements are doubly -+ * linked so that an arbitrary element can be removed without a need to -+ * traverse the list. New elements can be added to the list before or -+ * after an existing element, at the head of the list, or at the end of -+ * the list. A tail queue may be traversed in either direction. -+ * -+ * A circle queue is headed by a pair of pointers, one to the head of the -+ * list and the other to the tail of the list. The elements are doubly -+ * linked so that an arbitrary element can be removed without a need to -+ * traverse the list. New elements can be added to the list before or after -+ * an existing element, at the head of the list, or at the end of the list. -+ * A circle queue may be traversed in either direction, but has a more -+ * complex end of list detection. -+ * -+ * For details on the use of these macros, see the queue(3) manual page. -+ */ -+ -+/* -+ * List definitions. -+ */ -+#define LIST_HEAD(name, type) \ -+struct name { \ -+ struct type *lh_first; /* first element */ \ -+} -+ -+#define LIST_HEAD_INITIALIZER(head) \ -+ { NULL } -+ -+#define LIST_ENTRY(type) \ -+struct { \ -+ struct type *le_next; /* next element */ \ -+ struct type **le_prev; /* address of previous next element */ \ -+} -+ -+/* -+ * List functions. -+ */ -+#define LIST_INIT(head) do { \ -+ (head)->lh_first = NULL; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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; \ -+ (listelm)->field.le_next = (elm); \ -+ (elm)->field.le_prev = &(listelm)->field.le_next; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 (/*CONSTCOND*/0) -+ -+#define 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 (/*CONSTCOND*/0) -+ -+#define 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; \ -+} while (/*CONSTCOND*/0) -+ -+#define LIST_FOREACH(var, head, field) \ -+ for ((var) = ((head)->lh_first); \ -+ (var); \ -+ (var) = ((var)->field.le_next)) -+ -+/* -+ * List access methods. -+ */ -+#define LIST_EMPTY(head) ((head)->lh_first == NULL) -+#define LIST_FIRST(head) ((head)->lh_first) -+#define LIST_NEXT(elm, field) ((elm)->field.le_next) -+ -+ -+/* -+ * Singly-linked List definitions. -+ */ -+#define SLIST_HEAD(name, type) \ -+struct name { \ -+ struct type *slh_first; /* first element */ \ -+} -+ -+#define SLIST_HEAD_INITIALIZER(head) \ -+ { NULL } -+ -+#define SLIST_ENTRY(type) \ -+struct { \ -+ struct type *sle_next; /* next element */ \ -+} -+ -+/* -+ * Singly-linked List functions. -+ */ -+#define SLIST_INIT(head) do { \ -+ (head)->slh_first = NULL; \ -+} while (/*CONSTCOND*/0) -+ -+#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ -+ (elm)->field.sle_next = (slistelm)->field.sle_next; \ -+ (slistelm)->field.sle_next = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define SLIST_INSERT_HEAD(head, elm, field) do { \ -+ (elm)->field.sle_next = (head)->slh_first; \ -+ (head)->slh_first = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define SLIST_REMOVE_HEAD(head, field) do { \ -+ (head)->slh_first = (head)->slh_first->field.sle_next; \ -+} while (/*CONSTCOND*/0) -+ -+#define SLIST_REMOVE(head, elm, type, field) do { \ -+ if ((head)->slh_first == (elm)) { \ -+ SLIST_REMOVE_HEAD((head), field); \ -+ } \ -+ else { \ -+ struct type *curelm = (head)->slh_first; \ -+ while(curelm->field.sle_next != (elm)) \ -+ curelm = curelm->field.sle_next; \ -+ curelm->field.sle_next = \ -+ curelm->field.sle_next->field.sle_next; \ -+ } \ -+} while (/*CONSTCOND*/0) -+ -+#define SLIST_FOREACH(var, head, field) \ -+ for((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next) -+ -+/* -+ * Singly-linked List access methods. -+ */ -+#define SLIST_EMPTY(head) ((head)->slh_first == NULL) -+#define SLIST_FIRST(head) ((head)->slh_first) -+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) -+ -+ -+/* -+ * Singly-linked Tail queue declarations. -+ */ -+#define STAILQ_HEAD(name, type) \ -+struct name { \ -+ struct type *stqh_first; /* first element */ \ -+ struct type **stqh_last; /* addr of last next element */ \ -+} -+ -+#define STAILQ_HEAD_INITIALIZER(head) \ -+ { NULL, &(head).stqh_first } -+ -+#define STAILQ_ENTRY(type) \ -+struct { \ -+ struct type *stqe_next; /* next element */ \ -+} -+ -+/* -+ * Singly-linked Tail queue functions. -+ */ -+#define STAILQ_INIT(head) do { \ -+ (head)->stqh_first = NULL; \ -+ (head)->stqh_last = &(head)->stqh_first; \ -+} while (/*CONSTCOND*/0) -+ -+#define STAILQ_INSERT_HEAD(head, elm, field) do { \ -+ if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \ -+ (head)->stqh_last = &(elm)->field.stqe_next; \ -+ (head)->stqh_first = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define STAILQ_INSERT_TAIL(head, elm, field) do { \ -+ (elm)->field.stqe_next = NULL; \ -+ *(head)->stqh_last = (elm); \ -+ (head)->stqh_last = &(elm)->field.stqe_next; \ -+} while (/*CONSTCOND*/0) -+ -+#define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ -+ if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\ -+ (head)->stqh_last = &(elm)->field.stqe_next; \ -+ (listelm)->field.stqe_next = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define STAILQ_REMOVE_HEAD(head, field) do { \ -+ if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \ -+ (head)->stqh_last = &(head)->stqh_first; \ -+} while (/*CONSTCOND*/0) -+ -+#define STAILQ_REMOVE(head, elm, type, field) do { \ -+ if ((head)->stqh_first == (elm)) { \ -+ STAILQ_REMOVE_HEAD((head), field); \ -+ } else { \ -+ struct type *curelm = (head)->stqh_first; \ -+ while (curelm->field.stqe_next != (elm)) \ -+ curelm = curelm->field.stqe_next; \ -+ if ((curelm->field.stqe_next = \ -+ curelm->field.stqe_next->field.stqe_next) == NULL) \ -+ (head)->stqh_last = &(curelm)->field.stqe_next; \ -+ } \ -+} while (/*CONSTCOND*/0) -+ -+#define STAILQ_FOREACH(var, head, field) \ -+ for ((var) = ((head)->stqh_first); \ -+ (var); \ -+ (var) = ((var)->field.stqe_next)) -+ -+#define STAILQ_CONCAT(head1, head2) do { \ -+ if (!STAILQ_EMPTY((head2))) { \ -+ *(head1)->stqh_last = (head2)->stqh_first; \ -+ (head1)->stqh_last = (head2)->stqh_last; \ -+ STAILQ_INIT((head2)); \ -+ } \ -+} while (/*CONSTCOND*/0) -+ -+/* -+ * Singly-linked Tail queue access methods. -+ */ -+#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL) -+#define STAILQ_FIRST(head) ((head)->stqh_first) -+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next) -+ -+ -+/* -+ * Simple queue definitions. -+ */ -+#define 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) \ -+ { NULL, &(head).sqh_first } -+ -+#define SIMPLEQ_ENTRY(type) \ -+struct { \ -+ struct type *sqe_next; /* next element */ \ -+} -+ -+/* -+ * Simple queue functions. -+ */ -+#define SIMPLEQ_INIT(head) do { \ -+ (head)->sqh_first = NULL; \ -+ (head)->sqh_last = &(head)->sqh_first; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 (/*CONSTCOND*/0) -+ -+#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ -+ (elm)->field.sqe_next = NULL; \ -+ *(head)->sqh_last = (elm); \ -+ (head)->sqh_last = &(elm)->field.sqe_next; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 (/*CONSTCOND*/0) -+ -+#define SIMPLEQ_REMOVE_HEAD(head, field) do { \ -+ if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ -+ (head)->sqh_last = &(head)->sqh_first; \ -+} while (/*CONSTCOND*/0) -+ -+#define SIMPLEQ_REMOVE(head, elm, type, field) do { \ -+ if ((head)->sqh_first == (elm)) { \ -+ SIMPLEQ_REMOVE_HEAD((head), field); \ -+ } else { \ -+ struct type *curelm = (head)->sqh_first; \ -+ while (curelm->field.sqe_next != (elm)) \ -+ curelm = curelm->field.sqe_next; \ -+ if ((curelm->field.sqe_next = \ -+ curelm->field.sqe_next->field.sqe_next) == NULL) \ -+ (head)->sqh_last = &(curelm)->field.sqe_next; \ -+ } \ -+} while (/*CONSTCOND*/0) -+ -+#define SIMPLEQ_FOREACH(var, head, field) \ -+ for ((var) = ((head)->sqh_first); \ -+ (var); \ -+ (var) = ((var)->field.sqe_next)) -+ -+/* -+ * Simple queue access methods. -+ */ -+#define SIMPLEQ_EMPTY(head) ((head)->sqh_first == NULL) -+#define SIMPLEQ_FIRST(head) ((head)->sqh_first) -+#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) -+ -+ -+/* -+ * Tail queue definitions. -+ */ -+#define _TAILQ_HEAD(name, type, qual) \ -+struct name { \ -+ qual type *tqh_first; /* first element */ \ -+ qual type *qual *tqh_last; /* addr of last next element */ \ -+} -+#define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,) -+ -+#define TAILQ_HEAD_INITIALIZER(head) \ -+ { NULL, &(head).tqh_first } -+ -+#define _TAILQ_ENTRY(type, qual) \ -+struct { \ -+ qual type *tqe_next; /* next element */ \ -+ qual type *qual *tqe_prev; /* address of previous next element */\ -+} -+#define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,) -+ -+/* -+ * Tail queue functions. -+ */ -+#define TAILQ_INIT(head) do { \ -+ (head)->tqh_first = NULL; \ -+ (head)->tqh_last = &(head)->tqh_first; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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; \ -+ else \ -+ (head)->tqh_last = &(elm)->field.tqe_next; \ -+ (head)->tqh_first = (elm); \ -+ (elm)->field.tqe_prev = &(head)->tqh_first; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 (/*CONSTCOND*/0) -+ -+#define 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; \ -+ else \ -+ (head)->tqh_last = &(elm)->field.tqe_next; \ -+ (listelm)->field.tqe_next = (elm); \ -+ (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 (/*CONSTCOND*/0) -+ -+#define 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; \ -+} while (/*CONSTCOND*/0) -+ -+#define TAILQ_FOREACH(var, head, field) \ -+ for ((var) = ((head)->tqh_first); \ -+ (var); \ -+ (var) = ((var)->field.tqe_next)) -+ -+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ -+ for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \ -+ (var); \ -+ (var) = (*(((struct headname *)((var)->field.tqe_prev))->tqh_last))) -+ -+#define TAILQ_CONCAT(head1, head2, field) do { \ -+ if (!TAILQ_EMPTY(head2)) { \ -+ *(head1)->tqh_last = (head2)->tqh_first; \ -+ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ -+ (head1)->tqh_last = (head2)->tqh_last; \ -+ TAILQ_INIT((head2)); \ -+ } \ -+} while (/*CONSTCOND*/0) -+ -+/* -+ * Tail queue access methods. -+ */ -+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL) -+#define TAILQ_FIRST(head) ((head)->tqh_first) -+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) -+ -+#define TAILQ_LAST(head, headname) \ -+ (*(((struct headname *)((head)->tqh_last))->tqh_last)) -+#define TAILQ_PREV(elm, headname, field) \ -+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) -+ -+ -+/* -+ * Circular queue definitions. -+ */ -+#define CIRCLEQ_HEAD(name, type) \ -+struct name { \ -+ struct type *cqh_first; /* first element */ \ -+ struct type *cqh_last; /* last element */ \ -+} -+ -+#define CIRCLEQ_HEAD_INITIALIZER(head) \ -+ { (void *)&head, (void *)&head } -+ -+#define CIRCLEQ_ENTRY(type) \ -+struct { \ -+ struct type *cqe_next; /* next element */ \ -+ struct type *cqe_prev; /* previous element */ \ -+} -+ -+/* -+ * Circular queue functions. -+ */ -+#define CIRCLEQ_INIT(head) do { \ -+ (head)->cqh_first = (void *)(head); \ -+ (head)->cqh_last = (void *)(head); \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 == (void *)(head)) \ -+ (head)->cqh_last = (elm); \ -+ else \ -+ (listelm)->field.cqe_next->field.cqe_prev = (elm); \ -+ (listelm)->field.cqe_next = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define 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 == (void *)(head)) \ -+ (head)->cqh_first = (elm); \ -+ else \ -+ (listelm)->field.cqe_prev->field.cqe_next = (elm); \ -+ (listelm)->field.cqe_prev = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ -+ (elm)->field.cqe_next = (head)->cqh_first; \ -+ (elm)->field.cqe_prev = (void *)(head); \ -+ if ((head)->cqh_last == (void *)(head)) \ -+ (head)->cqh_last = (elm); \ -+ else \ -+ (head)->cqh_first->field.cqe_prev = (elm); \ -+ (head)->cqh_first = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ -+ (elm)->field.cqe_next = (void *)(head); \ -+ (elm)->field.cqe_prev = (head)->cqh_last; \ -+ if ((head)->cqh_first == (void *)(head)) \ -+ (head)->cqh_first = (elm); \ -+ else \ -+ (head)->cqh_last->field.cqe_next = (elm); \ -+ (head)->cqh_last = (elm); \ -+} while (/*CONSTCOND*/0) -+ -+#define CIRCLEQ_REMOVE(head, elm, field) do { \ -+ if ((elm)->field.cqe_next == (void *)(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 == (void *)(head)) \ -+ (head)->cqh_first = (elm)->field.cqe_next; \ -+ else \ -+ (elm)->field.cqe_prev->field.cqe_next = \ -+ (elm)->field.cqe_next; \ -+} while (/*CONSTCOND*/0) -+ -+#define CIRCLEQ_FOREACH(var, head, field) \ -+ for ((var) = ((head)->cqh_first); \ -+ (var) != (const void *)(head); \ -+ (var) = ((var)->field.cqe_next)) -+ -+#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ -+ for ((var) = ((head)->cqh_last); \ -+ (var) != (const void *)(head); \ -+ (var) = ((var)->field.cqe_prev)) -+ -+/* -+ * Circular queue access methods. -+ */ -+#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) -+#define CIRCLEQ_FIRST(head) ((head)->cqh_first) -+#define CIRCLEQ_LAST(head) ((head)->cqh_last) -+#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) -+#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) -+ -+#define CIRCLEQ_LOOP_NEXT(head, elm, field) \ -+ (((elm)->field.cqe_next == (void *)(head)) \ -+ ? ((head)->cqh_first) \ -+ : (elm->field.cqe_next)) -+#define CIRCLEQ_LOOP_PREV(head, elm, field) \ -+ (((elm)->field.cqe_prev == (void *)(head)) \ -+ ? ((head)->cqh_last) \ -+ : (elm->field.cqe_prev)) -+ -+#endif /* sys/queue.h */ -diff -Nur ulogd-2.0.2.orig/output/sqlite3/ulogd_output_SQLITE3.c ulogd-2.0.2/output/sqlite3/ulogd_output_SQLITE3.c ---- ulogd-2.0.2.orig/output/sqlite3/ulogd_output_SQLITE3.c 2012-08-03 16:11:53.000000000 +0200 -+++ ulogd-2.0.2/output/sqlite3/ulogd_output_SQLITE3.c 2013-10-05 21:01:46.000000000 +0200 -@@ -36,7 +36,11 @@ - #include <ulogd/ulogd.h> - #include <ulogd/conffile.h> - #include <sqlite3.h> -+#if defined(HAVE_SYS_QUEUE_H) - #include <sys/queue.h> -+#else -+#include "queue.h" -+#endif - - #define CFG_BUFFER_DEFAULT 10 - -diff -Nur ulogd-2.0.2.orig/src/ulogd.c ulogd-2.0.2/src/ulogd.c ---- ulogd-2.0.2.orig/src/ulogd.c 2013-03-01 16:45:23.000000000 +0100 -+++ ulogd-2.0.2/src/ulogd.c 2013-10-05 21:01:46.000000000 +0200 -@@ -78,7 +78,7 @@ - static FILE *logfile = NULL; /* logfile pointer */ - static char *ulogd_logfile = NULL; - static const char *ulogd_configfile = ULOGD_CONFIGFILE; --static FILE syslog_dummy; -+static FILE *syslog_dummy; - - static int info_mode = 0; - -@@ -420,7 +420,7 @@ - if (level < loglevel_ce.u.value) - return; - -- if (logfile == &syslog_dummy) { -+ if (logfile == syslog_dummy) { - /* FIXME: this omits the 'file' string */ - va_start(ap, format); - vsyslog(ulogd2syslog_level(level), format, ap); -@@ -941,7 +941,7 @@ - logfile = stdout; - } else if (!strcmp(name, "syslog")) { - openlog("ulogd", LOG_PID, LOG_DAEMON); -- logfile = &syslog_dummy; -+ logfile = syslog_dummy; - } else { - logfile = fopen(ulogd_logfile, "a"); - if (!logfile) { -@@ -1070,7 +1070,7 @@ - unload_plugins(); - #endif - -- if (logfile != NULL && logfile != stdout && logfile != &syslog_dummy) { -+ if (logfile != NULL && logfile != stdout && logfile != syslog_dummy) { - fclose(logfile); - logfile = NULL; - } -@@ -1090,7 +1090,7 @@ - switch (signal) { - case SIGHUP: - /* reopen logfile */ -- if (logfile != stdout && logfile != &syslog_dummy) { -+ if (logfile != stdout && logfile != syslog_dummy) { - fclose(logfile); - logfile = fopen(ulogd_logfile, "a"); - if (!logfile) { |