Add netfilter/nfqueue interface.

It's almost like nflog but with different structures/constants.

diff --git a/configure b/configure
index 24587c894ba5fbb936f69fe524730dde33f960a2..65da84d6d0502fdcc968ce6cc2e96ec80dfaac05 100755 (executable)
--- a/configure
+++ b/configure
@@ -11161,11 +11161,14 @@ cat >>conftest.$ac_ext <<_ACEOF
 
 $ac_includes_default
 #include <sys/socket.h>
 
 $ac_includes_default
 #include <sys/socket.h>

+#include <netinet/in.h>

 #include <linux/types.h>
 
 #include <linux/netlink.h>
 #include <linux/types.h>
 
 #include <linux/netlink.h>

+#include <linux/netfilter.h>

 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netfilter/nfnetlink_log.h>
 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netfilter/nfnetlink_log.h>

+#include <linux/netfilter/nfnetlink_queue.h>

 int
 main ()
 {
 int
 main ()
 {

diff --git a/configure.in b/configure.in
index 47e0b70cb7a71d8676a423a7dcea552bf54887a9..1a92983dc376bd068a72c5374e9405ebb6e2cd59 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -1347,11 +1347,14 @@ linux*)
          AC_TRY_COMPILE([
 AC_INCLUDES_DEFAULT
 #include <sys/socket.h>
          AC_TRY_COMPILE([
 AC_INCLUDES_DEFAULT
 #include <sys/socket.h>

+#include <netinet/in.h>

 #include <linux/types.h>
 
 #include <linux/netlink.h>
 #include <linux/types.h>
 
 #include <linux/netlink.h>

+#include <linux/netfilter.h>

 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netfilter/nfnetlink.h>

-#include <linux/netfilter/nfnetlink_log.h>],
+#include <linux/netfilter/nfnetlink_log.h>
+#include <linux/netfilter/nfnetlink_queue.h>],

            [],
            ac_cv_netfilter_can_compile=yes,
            ac_cv_netfilter_can_compile=no))
            [],
            ac_cv_netfilter_can_compile=yes,
            ac_cv_netfilter_can_compile=no))

diff --git a/pcap-netfilter-linux.c b/pcap-netfilter-linux.c
index 323cb18dbbab1af40bb2f64d5ef64c951c3b74a6..48f29b02529407e0ad734c2f79306dc4be313858 100644 (file)
--- a/pcap-netfilter-linux.c
+++ b/pcap-netfilter-linux.c
@@ -51,17 +51,33 @@
 #include <linux/types.h>
 
 #include <linux/netlink.h>
 #include <linux/types.h>
 
 #include <linux/netlink.h>

+#include <linux/netfilter.h>

 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netfilter/nfnetlink_log.h>
 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netfilter/nfnetlink_log.h>

+#include <linux/netfilter/nfnetlink_queue.h>

 
 

+/* NOTE: if your program drops privilages after pcap_activate() it WON'T work with nfqueue.
+ *       It took me quite some time to debug ;/ 
+ *
+ *       Sending any data to nfnetlink socket requires CAP_NET_ADMIN privilages,
+ *       and in nfqueue we need to send verdict reply after recving packet.
+ *
+ *       In tcpdump you can disable dropping privilages with -Z root
+ */
+ 

 #include "pcap-netfilter-linux.h"
 
 #define HDR_LENGTH (NLMSG_LENGTH(NLMSG_ALIGN(sizeof(struct nfgenmsg))))
 
 #define NFLOG_IFACE "nflog"
 #include "pcap-netfilter-linux.h"
 
 #define HDR_LENGTH (NLMSG_LENGTH(NLMSG_ALIGN(sizeof(struct nfgenmsg))))
 
 #define NFLOG_IFACE "nflog"

+#define NFQUEUE_IFACE "nfqueue"
+
+typedef enum { OTHER = -1, NFLOG, NFQUEUE } nftype_t;
+
+static int nfqueue_send_verdict(const pcap_t *handle, u_int16_t group_id, u_int32_t id, u_int32_t verdict);

 
 static int
 
 static int

-nflog_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
+netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)

 {
        const unsigned char *buf;
        int count = 0;
 {
        const unsigned char *buf;
        int count = 0;


@@ -85,6 +101,7 @@ nflog_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char
        while (len >= NLMSG_SPACE(0)) {
                const struct nlmsghdr *nlh = (const struct nlmsghdr *) buf;
                u_int32_t msg_len;
        while (len >= NLMSG_SPACE(0)) {
                const struct nlmsghdr *nlh = (const struct nlmsghdr *) buf;
                u_int32_t msg_len;

+               nftype_t type = OTHER;

 
                if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || len < nlh->nlmsg_len) {
                        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %d) (nlmsg_len: %u)", len, nlh->nlmsg_len);
 
                if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || len < nlh->nlmsg_len) {
                        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %d) (nlmsg_len: %u)", len, nlh->nlmsg_len);


@@ -93,10 +110,19 @@ nflog_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char
 
                if (NFNL_SUBSYS_ID(nlh->nlmsg_type) == NFNL_SUBSYS_ULOG && 
                        NFNL_MSG_TYPE(nlh->nlmsg_type) == NFULNL_MSG_PACKET) 
 
                if (NFNL_SUBSYS_ID(nlh->nlmsg_type) == NFNL_SUBSYS_ULOG && 
                        NFNL_MSG_TYPE(nlh->nlmsg_type) == NFULNL_MSG_PACKET) 

-               {
+                               type = NFLOG;
+
+               if (NFNL_SUBSYS_ID(nlh->nlmsg_type) == NFNL_SUBSYS_QUEUE && 
+                       NFNL_MSG_TYPE(nlh->nlmsg_type) == NFQNL_MSG_PACKET)
+                               type = NFQUEUE;
+
+               if (type != OTHER) {

                        const unsigned char *payload = NULL;
                        struct pcap_pkthdr pkth;
 
                        const unsigned char *payload = NULL;
                        struct pcap_pkthdr pkth;
 

+                       const struct nfgenmsg *nfg;
+                       int id = 0;
+

                        if (handle->linktype != DLT_NFLOG) {
                                const struct nfattr *payload_attr = NULL;
 
                        if (handle->linktype != DLT_NFLOG) {
                                const struct nfattr *payload_attr = NULL;
 


@@ -105,15 +131,32 @@ nflog_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char
                                        return -1;
                                }
 
                                        return -1;
                                }
 

+                               nfg = NLMSG_DATA(nlh);

                                if (nlh->nlmsg_len > HDR_LENGTH) {
                                if (nlh->nlmsg_len > HDR_LENGTH) {

-                                       struct nfattr *attr = NFM_NFA(NLMSG_DATA(nlh));
+                                       struct nfattr *attr = NFM_NFA(nfg);

                                        int attr_len = nlh->nlmsg_len - NLMSG_ALIGN(HDR_LENGTH);
 
                                        while (NFA_OK(attr, attr_len)) {
                                        int attr_len = nlh->nlmsg_len - NLMSG_ALIGN(HDR_LENGTH);
 
                                        while (NFA_OK(attr, attr_len)) {

-                                               switch (NFA_TYPE(attr)) {
-                                                       case NFULA_PAYLOAD:
-                                                               payload_attr = attr;
-                                                               break;
+                                               if (type == NFQUEUE) {
+                                                       switch (NFA_TYPE(attr)) {
+                                                               case NFQA_PACKET_HDR:
+                                                                       {
+                                                                               const struct nfqnl_msg_packet_hdr *pkt_hdr = (const struct nfqnl_msg_packet_hdr *) NFA_DATA(attr);
+
+                                                                               id = ntohl(pkt_hdr->packet_id);
+                                                                               break;
+                                                                       }
+                                                               case NFQA_PAYLOAD:
+                                                                       payload_attr = attr;
+                                                                       break;
+                                                       }
+
+                                               } else if (type == NFLOG) {
+                                                       switch (NFA_TYPE(attr)) {
+                                                               case NFULA_PAYLOAD:
+                                                                       payload_attr = attr;
+                                                                       break;
+                                                       }

                                                }
                                                attr = NFA_NEXT(attr, attr_len);
                                        }
                                                }
                                                attr = NFA_NEXT(attr, attr_len);
                                        }


@@ -141,6 +184,11 @@ nflog_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char
                                        count++;
                                }
                        }
                                        count++;
                                }
                        }

+
+                       if (type == NFQUEUE) {
+                               /* XXX, possible responses: NF_DROP, NF_ACCEPT, NF_STOLEN, NF_QUEUE, NF_REPEAT, NF_STOP */
+                               nfqueue_send_verdict(handle, ntohs(nfg->res_id), id, NF_ACCEPT);
+                       }

                }
 
                msg_len = NLMSG_ALIGN(nlh->nlmsg_len);
                }
 
                msg_len = NLMSG_ALIGN(nlh->nlmsg_len);


@@ -183,7 +231,7 @@ struct my_nfattr {
 };
 
 static int
 };
 
 static int

-nflog_send_config_msg(const pcap_t *handle, u_int8_t family, u_int16_t res_id, const struct my_nfattr *mynfa)
+netfilter_send_config_msg(const pcap_t *handle, u_int16_t msg_type, int ack, u_int8_t family, u_int16_t res_id, const struct my_nfattr *mynfa)

 {
        char buf[1024] __attribute__ ((aligned));
 
 {
        char buf[1024] __attribute__ ((aligned));
 


@@ -198,8 +246,8 @@ nflog_send_config_msg(const pcap_t *handle, u_int8_t family, u_int16_t res_id, c
        ++seq_id;
 
        nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nfgenmsg));
        ++seq_id;
 
        nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nfgenmsg));

-       nlh->nlmsg_type = (NFNL_SUBSYS_ULOG << 8) | NFULNL_MSG_CONFIG;
-       nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
+       nlh->nlmsg_type = msg_type;
+       nlh->nlmsg_flags = NLM_F_REQUEST | (ack ? NLM_F_ACK : 0);

        nlh->nlmsg_pid = 0;     /* to kernel */
        nlh->nlmsg_seq = seq_id;
 
        nlh->nlmsg_pid = 0;     /* to kernel */
        nlh->nlmsg_seq = seq_id;
 


@@ -222,6 +270,9 @@ nflog_send_config_msg(const pcap_t *handle, u_int8_t family, u_int16_t res_id, c
        if (sendto(handle->fd, nlh, nlh->nlmsg_len, 0, (struct sockaddr *) &snl, sizeof(snl)) == -1)
                return -1;
 
        if (sendto(handle->fd, nlh, nlh->nlmsg_len, 0, (struct sockaddr *) &snl, sizeof(snl)) == -1)
                return -1;
 

+       if (!ack)
+               return 0;
+

        /* waiting for reply loop */
        do {
                socklen_t addrlen = sizeof(snl);
        /* waiting for reply loop */
        do {
                socklen_t addrlen = sizeof(snl);


@@ -260,6 +311,12 @@ nflog_send_config_msg(const pcap_t *handle, u_int8_t family, u_int16_t res_id, c
        return -1; /* never here */
 }
 
        return -1; /* never here */
 }
 

+static int
+nflog_send_config_msg(const pcap_t *handle, u_int8_t family, u_int16_t group_id, const struct my_nfattr *mynfa)
+{
+       return netfilter_send_config_msg(handle, (NFNL_SUBSYS_ULOG << 8) | NFULNL_MSG_CONFIG, 1, family, group_id, mynfa);
+}
+

 static int
 nflog_send_config_cmd(const pcap_t *handle, u_int16_t group_id, u_int8_t cmd, u_int8_t family)
 {
 static int
 nflog_send_config_cmd(const pcap_t *handle, u_int16_t group_id, u_int8_t cmd, u_int8_t family)
 {


@@ -292,20 +349,79 @@ nflog_send_config_mode(const pcap_t *handle, u_int16_t group_id, u_int8_t copy_m
 }
 
 static int
 }
 
 static int

-nflog_activate(pcap_t* handle)
+nfqueue_send_verdict(const pcap_t *handle, u_int16_t group_id, u_int32_t id, u_int32_t verdict)
+{
+       struct nfqnl_msg_verdict_hdr msg;
+       struct my_nfattr nfa;
+
+       msg.id = htonl(id);
+       msg.verdict = htonl(verdict);
+
+       nfa.data = &msg;
+       nfa.nfa_type = NFQA_VERDICT_HDR;
+       nfa.nfa_len = sizeof(msg);
+
+       return netfilter_send_config_msg(handle, (NFNL_SUBSYS_QUEUE << 8) | NFQNL_MSG_VERDICT, 0, AF_UNSPEC, group_id, &nfa);
+}
+
+static int
+nfqueue_send_config_msg(const pcap_t *handle, u_int8_t family, u_int16_t group_id, const struct my_nfattr *mynfa)
+{
+       return netfilter_send_config_msg(handle, (NFNL_SUBSYS_QUEUE << 8) | NFQNL_MSG_CONFIG, 1, family, group_id, mynfa);
+}
+
+static int
+nfqueue_send_config_cmd(const pcap_t *handle, u_int16_t group_id, u_int8_t cmd, u_int16_t pf)
+{
+       struct nfqnl_msg_config_cmd msg;
+       struct my_nfattr nfa;
+
+       msg.command = cmd;
+       msg.pf = htons(pf);
+
+       nfa.data = &msg;
+       nfa.nfa_type = NFQA_CFG_CMD;
+       nfa.nfa_len = sizeof(msg);
+
+       return nfqueue_send_config_msg(handle, AF_UNSPEC, group_id, &nfa);
+}
+
+static int 
+nfqueue_send_config_mode(const pcap_t *handle, u_int16_t group_id, u_int8_t copy_mode, u_int32_t copy_range)
+{
+       struct nfqnl_msg_config_params msg;
+       struct my_nfattr nfa;
+
+       msg.copy_range = htonl(copy_range);
+       msg.copy_mode = copy_mode;
+
+       nfa.data = &msg;
+       nfa.nfa_type = NFQA_CFG_PARAMS;
+       nfa.nfa_len = sizeof(msg);
+
+       return nfqueue_send_config_msg(handle, AF_UNSPEC, group_id, &nfa);
+}
+
+static int
+netfilter_activate(pcap_t* handle)

 {
        const char *dev = handle->opt.source;
        unsigned short groups[32];
        int group_count = 0;
 {
        const char *dev = handle->opt.source;
        unsigned short groups[32];
        int group_count = 0;

+       nftype_t type = OTHER;

        int i;
 
        int i;
 

-       if (strncmp(dev, NFLOG_IFACE, strlen(NFLOG_IFACE)) == 0) {
-               dev += strlen(NFLOG_IFACE);
-
-               /* nflog:30,33,42 looks nice, allow it */
-               if (*dev == ':')
-                       dev++;
+       if (strncmp(dev, NFLOG_IFACE, strlen(NFLOG_IFACE)) == 0) {
+               dev += strlen(NFLOG_IFACE);
+               type = NFLOG;

 
 

+       } else if (strncmp(dev, NFQUEUE_IFACE, strlen(NFQUEUE_IFACE)) == 0) {
+               dev += strlen(NFQUEUE_IFACE);
+               type = NFQUEUE;
+       }
+ 
+       if (type != OTHER && *dev == ':') {
+               dev++;

                while (*dev) {
                        long int group_id;
                        char *end_dev;
                while (*dev) {
                        long int group_id;
                        char *end_dev;


@@ -335,7 +451,7 @@ nflog_activate(pcap_t* handle)
                }
        }
 
                }
        }
 

-       if (*dev) {
+       if (type == OTHER || *dev) {

                snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
                                "Can't get netfilter group(s) index from %s", 
                                handle->opt.source);
                snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
                                "Can't get netfilter group(s) index from %s", 
                                handle->opt.source);


@@ -351,8 +467,7 @@ nflog_activate(pcap_t* handle)
        /* Initialize some components of the pcap structure. */
        handle->bufsize = 128 + handle->snapshot;
        handle->offset = 0;
        /* Initialize some components of the pcap structure. */
        handle->bufsize = 128 + handle->snapshot;
        handle->offset = 0;

-       handle->linktype = DLT_NFLOG;
-       handle->read_op = nflog_read_linux;
+       handle->read_op = netfilter_read_linux;

        handle->inject_op = netfilter_inject_linux;
        handle->setfilter_op = install_bpf_program; /* no kernel filtering */
        handle->setdirection_op = NULL;
        handle->inject_op = netfilter_inject_linux;
        handle->setfilter_op = install_bpf_program; /* no kernel filtering */
        handle->setdirection_op = NULL;


@@ -369,12 +484,17 @@ nflog_activate(pcap_t* handle)
                return PCAP_ERROR;
        }
 
                return PCAP_ERROR;
        }
 

-       handle->dlt_list = (u_int *) malloc(sizeof(u_int) * 2);
-       if (handle->dlt_list != NULL) {
-               handle->dlt_list[0] = DLT_NFLOG;
-               handle->dlt_list[1] = DLT_IPV4;
-               handle->dlt_count = 2;
-       }
+       if (type == NFLOG) {
+               handle->linktype = DLT_NFLOG;
+               handle->dlt_list = (u_int *) malloc(sizeof(u_int) * 2);
+               if (handle->dlt_list != NULL) {
+                       handle->dlt_list[0] = DLT_NFLOG;
+                       handle->dlt_list[1] = DLT_IPV4;
+                       handle->dlt_count = 2;
+               }
+
+       } else
+               handle->linktype = DLT_IPV4;

 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {
 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {


@@ -382,27 +502,53 @@ nflog_activate(pcap_t* handle)
                goto close_fail;
        }
 
                goto close_fail;
        }
 

-       if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));
-               goto close_fail;
-       }
+       if (type == NFLOG) {
+               if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
+                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));
+                       goto close_fail;
+               }

 
 

-       if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));
-               goto close_fail;
-       }
+               if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
+                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));
+                       goto close_fail;
+               }
+
+               /* Bind socket to the nflog groups */
+               for (i = 0; i < group_count; i++) {
+                       if (nflog_send_config_cmd(handle, groups[i], NFULNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
+                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));
+                               goto close_fail;
+                       }

 
 

-       /* Bind socket to the nflog groups */
-       for (i = 0; i < group_count; i++) {
-               if (nflog_send_config_cmd(handle, groups[i], NFULNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));
+                       if (nflog_send_config_mode(handle, groups[i], NFULNL_COPY_PACKET, handle->snapshot) < 0) {
+                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_COPY_PACKET: %s", pcap_strerror(errno));
+                               goto close_fail;
+                       }
+               }
+
+       } else {
+               if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
+                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_CFG_CMD_PF_UNBIND: %s", pcap_strerror(errno));

                        goto close_fail;
                }
 
                        goto close_fail;
                }
 

-               if (nflog_send_config_mode(handle, groups[i], NFULNL_COPY_PACKET, handle->snapshot) < 0) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFULNL_COPY_PACKET: %s", pcap_strerror(errno));
+               if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
+                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_CFG_CMD_PF_BIND: %s", pcap_strerror(errno));

                        goto close_fail;
                }
                        goto close_fail;
                }

+
+               /* Bind socket to the nfqueue groups */
+               for (i = 0; i < group_count; i++) {
+                       if (nfqueue_send_config_cmd(handle, groups[i], NFQNL_CFG_CMD_BIND, AF_UNSPEC) < 0) {
+                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't listen on group group index: %s", pcap_strerror(errno));
+                               goto close_fail;
+                       }
+
+                       if (nfqueue_send_config_mode(handle, groups[i], NFQNL_COPY_PACKET, handle->snapshot) < 0) {
+                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "NFQNL_COPY_PACKET: %s", pcap_strerror(errno));
+                               goto close_fail;
+                       }
+               }

        }
 
        if (handle->opt.rfmon) {
        }
 
        if (handle->opt.rfmon) {


@@ -432,26 +578,31 @@ close_fail:
 }
 
 pcap_t *
 }
 
 pcap_t *

-nflog_create(const char *device, char *ebuf, int *is_ours)
+netfilter_create(const char *device, char *ebuf, int *is_ours)

 {
        const char *cp;
        pcap_t *p;
 
 {
        const char *cp;
        pcap_t *p;
 

-       /* Does this look like an nflog device? */
+       /* Does this look like an netfilter device? */

        cp = strrchr(device, '/');
        if (cp == NULL)
                cp = device;
        cp = strrchr(device, '/');
        if (cp == NULL)
                cp = device;

-       /* Does it begin with NFLOG_IFACE? */
-       if (strncmp(cp, NFLOG_IFACE, sizeof NFLOG_IFACE - 1) != 0) {
-               /* Nope, doesn't begin with NFLOG_IFACE */
+
+       /* Does it begin with NFLOG_IFACE or NFQUEUE_IFACE? */
+       if (strncmp(cp, NFLOG_IFACE, sizeof NFLOG_IFACE - 1) == 0)
+               cp += sizeof NFLOG_IFACE - 1;
+       else if (strncmp(cp, NFQUEUE_IFACE, sizeof NFQUEUE_IFACE - 1) == 0) 
+               cp += sizeof NFQUEUE_IFACE - 1;
+       else {
+               /* Nope, doesn't begin with NFLOG_IFACE nor NFQUEUE_IFACE */

                *is_ours = 0;
                return NULL;
        }
                *is_ours = 0;
                return NULL;
        }

+

        /*
         * Yes - is that either the end of the name, or is it followed
         * by a colon?
         */
        /*
         * Yes - is that either the end of the name, or is it followed
         * by a colon?
         */

-       cp += sizeof NFLOG_IFACE - 1;

        if (*cp != ':' && *cp != '\0') {
                /* Nope */
                *is_ours = 0;
        if (*cp != ':' && *cp != '\0') {
                /* Nope */
                *is_ours = 0;


@@ -465,12 +616,12 @@ nflog_create(const char *device, char *ebuf, int *is_ours)
        if (p == NULL)
                return (NULL);
 
        if (p == NULL)
                return (NULL);
 

-       p->activate_op = nflog_activate;
+       p->activate_op = netfilter_activate;

        return (p);
 }
 
 int 
        return (p);
 }
 
 int 

-nflog_findalldevs(pcap_if_t **alldevsp, char *err_str)
+netfilter_findalldevs(pcap_if_t **alldevsp, char *err_str)

 {
        pcap_if_t *found_dev = *alldevsp;
        int sock;
 {
        pcap_if_t *found_dev = *alldevsp;
        int sock;


@@ -488,5 +639,7 @@ nflog_findalldevs(pcap_if_t **alldevsp, char *err_str)
 
        if (pcap_add_if(&found_dev, NFLOG_IFACE, 0, "Linux netfilter log (NFLOG) interface", err_str) < 0)
                return -1;
 
        if (pcap_add_if(&found_dev, NFLOG_IFACE, 0, "Linux netfilter log (NFLOG) interface", err_str) < 0)
                return -1;

+       if (pcap_add_if(&found_dev, NFQUEUE_IFACE, 0, "Linux netfilter queue (NFQUEUE) interface", err_str) < 0)
+               return -1;

        return 0;
 }
        return 0;
 }

diff --git a/pcap-netfilter-linux.h b/pcap-netfilter-linux.h
index e16e0ec67f48edfeceb1db3bc2422b46e2e409f7..882a4021917281082c54d48ba9194da3a031ad9e 100644 (file)
--- a/pcap-netfilter-linux.h
+++ b/pcap-netfilter-linux.h
@@ -31,5 +31,5 @@
 /*
  * Prototypes for netlink-related functions
  */
 /*
  * Prototypes for netlink-related functions
  */

-int nflog_findalldevs(pcap_if_t **alldevsp, char *err_str);
-pcap_t *nflog_create(const char *device, char *ebuf, int *is_ours);
+int netfilter_findalldevs(pcap_if_t **alldevsp, char *err_str);
+pcap_t *netfilter_create(const char *device, char *ebuf, int *is_ours);

diff --git a/pcap.c b/pcap.c
index 8560c5fd5a70f274e51c04ce29aa851cddfa942a..bc661d20e015f269253b7af0348ad397335bbd2f 100644 (file)
--- a/pcap.c
+++ b/pcap.c
@@ -322,7 +322,7 @@ struct capture_source_type {
        { usb_findalldevs, usb_create },
 #endif
 #ifdef PCAP_SUPPORT_NETFILTER
        { usb_findalldevs, usb_create },
 #endif
 #ifdef PCAP_SUPPORT_NETFILTER

-       { nflog_findalldevs, nflog_create },
+       { netfilter_findalldevs, netfilter_create },

 #endif
 };
 
 #endif
 };