Merge pull request #1229 from guyharris/more-pcap-to-pcapint

[libpcap] / pcap-netfilter-linux.c

diff --git a/pcap-netfilter-linux.c b/pcap-netfilter-linux.c
index 018d3b89b90e47e2325f4bbbb0379b2b78825519..7b6e99884c4d5617cf9f308bf3735eba6feb6154 100644 (file)
--- a/pcap-netfilter-linux.c
+++ b/pcap-netfilter-linux.c
@@ -128,7 +128,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                } while ((len == -1) && (errno == EINTR || errno == ENOBUFS));
 
                if (len < 0) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno, "Can't receive packet");
                        return PCAP_ERROR;
                }
@@ -259,7 +259,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
 
                                gettimeofday(&pkth.ts, NULL);
                                if (handle->fcode.bf_insns == NULL ||
-                                               pcap_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen))
+                                               pcapint_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen))
                                {
                                        handlep->packets_read++;
                                        callback(user, &pkth, payload);
@@ -595,17 +595,17 @@ netfilter_activate(pcap_t* handle)
        handle->offset = 0;
        handle->read_op = netfilter_read_linux;
        handle->inject_op = netfilter_inject_linux;
-       handle->setfilter_op = pcap_install_bpf_program; /* no kernel filtering */
+       handle->setfilter_op = pcapint_install_bpf_program; /* no kernel filtering */
        handle->setdirection_op = NULL;
        handle->set_datalink_op = netfilter_set_datalink;
-       handle->getnonblock_op = pcap_getnonblock_fd;
-       handle->setnonblock_op = pcap_setnonblock_fd;
+       handle->getnonblock_op = pcapint_getnonblock_fd;
+       handle->setnonblock_op = pcapint_setnonblock_fd;
        handle->stats_op = netfilter_stats_linux;
 
        /* Create netlink socket */
        handle->fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_NETFILTER);
        if (handle->fd < 0) {
-               pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcapint_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
                    errno, "Can't create raw socket");
                return PCAP_ERROR;
        }
@@ -614,7 +614,7 @@ netfilter_activate(pcap_t* handle)
                handle->linktype = DLT_NFLOG;
                handle->dlt_list = (u_int *) malloc(sizeof(u_int) * 2);
                if (handle->dlt_list == NULL) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno,
                            "Can't allocate DLT list");
                        goto close_fail;
@@ -627,21 +627,21 @@ netfilter_activate(pcap_t* handle)
 
        handle->buffer = malloc(handle->bufsize);
        if (!handle->buffer) {
-               pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
+               pcapint_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE,
                    errno, "Can't allocate dump buffer");
                goto close_fail;
        }
 
        if (type == NFLOG) {
                if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno,
                            "NFULNL_CFG_CMD_PF_UNBIND");
                        goto close_fail;
                }
 
                if (nflog_send_config_cmd(handle, 0, NFULNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno, "NFULNL_CFG_CMD_PF_BIND");
                        goto close_fail;
                }
@@ -649,14 +649,14 @@ netfilter_activate(pcap_t* handle)
                /* 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) {
-                               pcap_fmt_errmsg_for_errno(handle->errbuf,
+                               pcapint_fmt_errmsg_for_errno(handle->errbuf,
                                    PCAP_ERRBUF_SIZE, errno,
                                    "Can't listen on group index");
                                goto close_fail;
                        }
 
                        if (nflog_send_config_mode(handle, groups[i], NFULNL_COPY_PACKET, handle->snapshot) < 0) {
-                               pcap_fmt_errmsg_for_errno(handle->errbuf,
+                               pcapint_fmt_errmsg_for_errno(handle->errbuf,
                                    PCAP_ERRBUF_SIZE, errno,
                                    "NFULNL_COPY_PACKET");
                                goto close_fail;
@@ -665,13 +665,13 @@ netfilter_activate(pcap_t* handle)
 
        } else {
                if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_UNBIND, AF_INET) < 0) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno, "NFQNL_CFG_CMD_PF_UNBIND");
                        goto close_fail;
                }
 
                if (nfqueue_send_config_cmd(handle, 0, NFQNL_CFG_CMD_PF_BIND, AF_INET) < 0) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno, "NFQNL_CFG_CMD_PF_BIND");
                        goto close_fail;
                }
@@ -679,14 +679,14 @@ netfilter_activate(pcap_t* handle)
                /* 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) {
-                               pcap_fmt_errmsg_for_errno(handle->errbuf,
+                               pcapint_fmt_errmsg_for_errno(handle->errbuf,
                                    PCAP_ERRBUF_SIZE, errno,
                                    "Can't listen on group index");
                                goto close_fail;
                        }
 
                        if (nfqueue_send_config_mode(handle, groups[i], NFQNL_COPY_PACKET, handle->snapshot) < 0) {
-                               pcap_fmt_errmsg_for_errno(handle->errbuf,
+                               pcapint_fmt_errmsg_for_errno(handle->errbuf,
                                    PCAP_ERRBUF_SIZE, errno,
                                    "NFQNL_COPY_PACKET");
                                goto close_fail;
@@ -698,7 +698,7 @@ netfilter_activate(pcap_t* handle)
                /*
                 * Monitor mode doesn't apply to netfilter devices.
                 */
-               pcap_cleanup_live_common(handle);
+               pcapint_cleanup_live_common(handle);
                return PCAP_ERROR_RFMON_NOTSUP;
        }
 
@@ -707,7 +707,7 @@ netfilter_activate(pcap_t* handle)
                 * Set the socket buffer size to the specified value.
                 */
                if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF, &handle->opt.buffer_size, sizeof(handle->opt.buffer_size)) == -1) {
-                       pcap_fmt_errmsg_for_errno(handle->errbuf,
+                       pcapint_fmt_errmsg_for_errno(handle->errbuf,
                            PCAP_ERRBUF_SIZE, errno, "SO_RCVBUF");
                        goto close_fail;
                }
@@ -717,7 +717,7 @@ netfilter_activate(pcap_t* handle)
        return 0;
 
 close_fail:
-       pcap_cleanup_live_common(handle);
+       pcapint_cleanup_live_common(handle);
        return PCAP_ERROR;
 }
 
@@ -774,7 +774,7 @@ netfilter_findalldevs(pcap_if_list_t *devlistp, char *err_str)
                /* if netlink is not supported this is not fatal */
                if (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT)
                        return 0;
-               pcap_fmt_errmsg_for_errno(err_str, PCAP_ERRBUF_SIZE,
+               pcapint_fmt_errmsg_for_errno(err_str, PCAP_ERRBUF_SIZE,
                    errno, "Can't open netlink socket");
                return -1;
        }
@@ -784,11 +784,11 @@ netfilter_findalldevs(pcap_if_list_t *devlistp, char *err_str)
         * The notion of "connected" vs. "disconnected" doesn't apply.
         * XXX - what about "up" and "running"?
         */
-       if (pcap_add_dev(devlistp, NFLOG_IFACE,
+       if (pcapint_add_dev(devlistp, NFLOG_IFACE,
            PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE,
            "Linux netfilter log (NFLOG) interface", err_str) == NULL)
                return -1;
-       if (pcap_add_dev(devlistp, NFQUEUE_IFACE,
+       if (pcapint_add_dev(devlistp, NFQUEUE_IFACE,
            PCAP_IF_CONNECTION_STATUS_NOT_APPLICABLE,
            "Linux netfilter queue (NFQUEUE) interface", err_str) == NULL)
                return -1;