Remove some workarounds for old compilers.

[libpcap] / pcap-netfilter-linux.c

diff --git a/pcap-netfilter-linux.c b/pcap-netfilter-linux.c
index d5c5dcdc485040adcbdf85805e600801e7092a6d..39a463d0009a962758e4017a5bed4b70b060fb42 100644 (file)
--- a/pcap-netfilter-linux.c
+++ b/pcap-netfilter-linux.c
@@ -91,7 +91,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
        struct pcap_netfilter *handlep = handle->priv;
        register u_char *bp, *ep;
        int count = 0;
-       int len;
+       ssize_t len;
 
        /*
         * Has "pcap_breakloop()" been called?
@@ -152,7 +152,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                 */
                if (handle->break_loop) {
                        handle->bp = bp;
-                       handle->cc = ep - bp;
+                       handle->cc = (int)(ep - bp);
                        if (count == 0) {
                                handle->break_loop = 0;
                                return PCAP_ERROR_BREAK;
@@ -168,7 +168,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                }
 
                if (nlh->nlmsg_len < sizeof(struct nlmsghdr) || (u_int)len < nlh->nlmsg_len) {
-                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %d) (nlmsg_len: %u)", len, nlh->nlmsg_len);
+                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Message truncated: (got: %zd) (nlmsg_len: %u)", len, nlh->nlmsg_len);
                        return -1;
                }
 
@@ -190,7 +190,7 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                                const struct nfattr *payload_attr = NULL;
 
                                if (nlh->nlmsg_len < HDR_LENGTH) {
-                                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Malformed message: (nlmsg_len: %u)", nlh->nlmsg_len);
+                                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Malformed message: (nlmsg_len: %u)", nlh->nlmsg_len);
                                        return -1;
                                }
 
@@ -240,7 +240,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 ||
-                                               bpf_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen))
+                                               pcap_filter(handle->fcode.bf_insns, payload, pkth.len, pkth.caplen))
                                {
                                        handlep->packets_read++;
                                        callback(user, &pkth, payload);
@@ -264,12 +264,12 @@ netfilter_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_c
                 * buffer.
                 */
                if (msg_len > ep - bp)
-                       msg_len = ep - bp;
+                       msg_len = (uint32_t)(ep - bp);
 
                bp += msg_len;
                if (count >= max_packets && !PACKET_COUNT_IS_UNLIMITED(max_packets)) {
                        handle->bp = bp;
-                       handle->cc = ep - bp;
+                       handle->cc = (int)(ep - bp);
                        if (handle->cc < 0)
                                handle->cc = 0;
                        return count;
@@ -299,9 +299,10 @@ netfilter_stats_linux(pcap_t *handle, struct pcap_stat *stats)
 }
 
 static int
-netfilter_inject_linux(pcap_t *handle, const void *buf _U_, size_t size _U_)
+netfilter_inject_linux(pcap_t *handle, const void *buf _U_, int size _U_)
 {
-       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on netfilter devices");
+       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+           "Packet injection is not supported on netfilter devices");
        return (-1);
 }
 
@@ -361,7 +362,11 @@ netfilter_send_config_msg(const pcap_t *handle, uint16_t msg_type, int ack, u_in
 
                /* ignore interrupt system call error */
                do {
-                       len = recvfrom(handle->fd, buf, sizeof(buf), 0, (struct sockaddr *) &snl, &addrlen);
+                       /*
+                        * The buffer is not so big that its size won't
+                        * fit into an int.
+                        */
+                       len = (int)recvfrom(handle->fd, buf, sizeof(buf), 0, (struct sockaddr *) &snl, &addrlen);
                } while ((len == -1) && (errno == EINTR));
 
                if (len <= 0)
@@ -508,7 +513,7 @@ netfilter_activate(pcap_t* handle)
                        char *end_dev;
 
                        if (group_count == 32) {
-                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
                                                "Maximum 32 netfilter groups! dev: %s",
                                                handle->opt.device);
                                return PCAP_ERROR;
@@ -517,7 +522,7 @@ netfilter_activate(pcap_t* handle)
                        group_id = strtol(dev, &end_dev, 0);
                        if (end_dev != dev) {
                                if (group_id < 0 || group_id > 65535) {
-                                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+                                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
                                                        "Netfilter group range from 0 to 65535 (got %ld)",
                                                        group_id);
                                        return PCAP_ERROR;
@@ -533,7 +538,7 @@ netfilter_activate(pcap_t* handle)
        }
 
        if (type == OTHER || *dev) {
-               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
                                "Can't get netfilter group(s) index from %s",
                                handle->opt.device);
                return PCAP_ERROR;