From f96475863d378f095579093774518084b3c7dbf8 Mon Sep 17 00:00:00 2001 From: Waldemar Brodkorb Date: Mon, 11 Nov 2013 21:31:52 +0100 Subject: convert to new autotool infrastructure --- package/ulogd/patches/autotools.patch | 734 --------------------- package/ulogd/patches/patch-config_h_in | 12 + package/ulogd/patches/patch-configure_ac | 11 + ...patch-filter_raw2packet_ulogd_raw2packet_BASE_c | 17 + package/ulogd/patches/patch-include_linux_tcp_h | 37 ++ package/ulogd/patches/patch-output_sqlite3_queue_h | 577 ++++++++++++++++ .../patch-output_sqlite3_ulogd_output_SQLITE3_c | 14 + package/ulogd/patches/patch-src_ulogd_c | 47 ++ 8 files changed, 715 insertions(+), 734 deletions(-) delete mode 100644 package/ulogd/patches/autotools.patch create mode 100644 package/ulogd/patches/patch-config_h_in create mode 100644 package/ulogd/patches/patch-configure_ac create mode 100644 package/ulogd/patches/patch-filter_raw2packet_ulogd_raw2packet_BASE_c create mode 100644 package/ulogd/patches/patch-include_linux_tcp_h create mode 100644 package/ulogd/patches/patch-output_sqlite3_queue_h create mode 100644 package/ulogd/patches/patch-output_sqlite3_ulogd_output_SQLITE3_c create mode 100644 package/ulogd/patches/patch-src_ulogd_c (limited to 'package/ulogd/patches') 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 header file. */ -+#undef HAVE_SYS_QUEUE_H -+ - /* Define to 1 if you have the 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 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 - #include - #include -+#if defined(HAVE_SYS_QUEUE_H) - #include -+#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) { diff --git a/package/ulogd/patches/patch-config_h_in b/package/ulogd/patches/patch-config_h_in new file mode 100644 index 000000000..1b768cdcd --- /dev/null +++ b/package/ulogd/patches/patch-config_h_in @@ -0,0 +1,12 @@ +--- ulogd-2.0.2.orig/config.h.in 2013-03-03 22:19:17.000000000 +0100 ++++ ulogd-2.0.2/config.h.in 2013-11-11 21:27:31.000000000 +0100 +@@ -66,6 +66,9 @@ + */ + #undef HAVE_SYS_NDIR_H + ++/* Define to 1 if you have the header file. */ ++#undef HAVE_SYS_QUEUE_H ++ + /* Define to 1 if you have the header file. */ + #undef HAVE_SYS_STAT_H + diff --git a/package/ulogd/patches/patch-configure_ac b/package/ulogd/patches/patch-configure_ac new file mode 100644 index 000000000..389b26f15 --- /dev/null +++ b/package/ulogd/patches/patch-configure_ac @@ -0,0 +1,11 @@ +--- ulogd-2.0.2.orig/configure.ac 2013-03-01 16:45:23.000000000 +0100 ++++ ulogd-2.0.2/configure.ac 2013-11-11 21:27:31.000000000 +0100 +@@ -32,7 +32,7 @@ fi + 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 --git a/package/ulogd/patches/patch-filter_raw2packet_ulogd_raw2packet_BASE_c b/package/ulogd/patches/patch-filter_raw2packet_ulogd_raw2packet_BASE_c new file mode 100644 index 000000000..b77ea9bf4 --- /dev/null +++ b/package/ulogd/patches/patch-filter_raw2packet_ulogd_raw2packet_BASE_c @@ -0,0 +1,17 @@ +--- 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-11-11 21:27:31.000000000 +0100 +@@ -588,10 +588,10 @@ static int _interp_udp(struct ulogd_plug + + /* 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 --git a/package/ulogd/patches/patch-include_linux_tcp_h b/package/ulogd/patches/patch-include_linux_tcp_h new file mode 100644 index 000000000..2752fc21b --- /dev/null +++ b/package/ulogd/patches/patch-include_linux_tcp_h @@ -0,0 +1,37 @@ +--- ulogd-2.0.2.orig/include/linux/tcp.h 1970-01-01 00:00:00.000000000 +0100 ++++ ulogd-2.0.2/include/linux/tcp.h 2013-11-11 21:27:31.000000000 +0100 +@@ -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 defines" ++# endif ++ u_int16_t window; ++ u_int16_t check; ++ u_int16_t urg_ptr; ++}; ++ diff --git a/package/ulogd/patches/patch-output_sqlite3_queue_h b/package/ulogd/patches/patch-output_sqlite3_queue_h new file mode 100644 index 000000000..9a3c55098 --- /dev/null +++ b/package/ulogd/patches/patch-output_sqlite3_queue_h @@ -0,0 +1,577 @@ +--- ulogd-2.0.2.orig/output/sqlite3/queue.h 1970-01-01 00:00:00.000000000 +0100 ++++ ulogd-2.0.2/output/sqlite3/queue.h 2013-11-11 21:27:31.000000000 +0100 +@@ -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 --git a/package/ulogd/patches/patch-output_sqlite3_ulogd_output_SQLITE3_c b/package/ulogd/patches/patch-output_sqlite3_ulogd_output_SQLITE3_c new file mode 100644 index 000000000..6de029c86 --- /dev/null +++ b/package/ulogd/patches/patch-output_sqlite3_ulogd_output_SQLITE3_c @@ -0,0 +1,14 @@ +--- 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-11-11 21:27:31.000000000 +0100 +@@ -36,7 +36,11 @@ + #include + #include + #include ++#if defined(HAVE_SYS_QUEUE_H) + #include ++#else ++#include "queue.h" ++#endif + + #define CFG_BUFFER_DEFAULT 10 + diff --git a/package/ulogd/patches/patch-src_ulogd_c b/package/ulogd/patches/patch-src_ulogd_c new file mode 100644 index 000000000..a30a3a95a --- /dev/null +++ b/package/ulogd/patches/patch-src_ulogd_c @@ -0,0 +1,47 @@ +--- ulogd-2.0.2.orig/src/ulogd.c 2013-03-01 16:45:23.000000000 +0100 ++++ ulogd-2.0.2/src/ulogd.c 2013-11-11 21:27:31.000000000 +0100 +@@ -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 @@ void __ulogd_log(int level, char *file, + 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 @@ static int logfile_open(const char *name + 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 @@ static void sigterm_handler(int signal) + 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 @@ static void signal_handler(int signal) + 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) { -- cgit v1.2.3