Clean up the ether_hostton() stuff.

[libpcap] / pcap-dbus.c

diff --git a/pcap-dbus.c b/pcap-dbus.c
index c878353b9f4bfd1ee9ebdf65965b72669fb90079..b1fb548ff4b3f1dc336d628415037bcc7e29f08f 100644 (file)
--- a/pcap-dbus.c
+++ b/pcap-dbus.c
@@ -11,8 +11,8 @@
  * 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. The name of the author may not be used to endorse or promote 
- * products derived from this software without specific prior written 
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior written
  * permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
@@ -29,7 +29,7 @@
  */
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
 #include <string.h>
@@ -66,9 +66,9 @@ dbus_read(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
        message = dbus_connection_pop_message(handlep->conn);
 
        while (!message) {
-               // XXX handle->opt.timeout = timeout_ms;
+               /* XXX handle->opt.timeout = timeout_ms; */
                if (!dbus_connection_read_write(handlep->conn, 100)) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Connection closed");
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Connection closed");
                        return -1;
                }
 
@@ -81,7 +81,7 @@ dbus_read(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
        }
 
        if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Disconnected");
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Disconnected");
                return -1;
        }
 
@@ -112,7 +112,7 @@ dbus_write(pcap_t *handle, const void *buf, size_t size)
        DBusMessage *msg;
 
        if (!(msg = dbus_message_demarshal(buf, size, &error))) {
-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dbus_message_demarshal() failed: %s", error.message);
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dbus_message_demarshal() failed: %s", error.message);
                dbus_error_free(&error);
                return -1;
        }
@@ -122,7 +122,7 @@ dbus_write(pcap_t *handle, const void *buf, size_t size)
 
        dbus_message_unref(msg);
        return 0;
-}                           
+}
 
 static int
 dbus_stats(pcap_t *handle, struct pcap_stat *stats)
@@ -160,21 +160,21 @@ dbus_activate(pcap_t *handle)
        #define N_RULES sizeof(rules)/sizeof(rules[0])
 
        struct pcap_dbus *handlep = handle->priv;
-       const char *dev = handle->opt.source;
+       const char *dev = handle->opt.device;
 
        DBusError error = DBUS_ERROR_INIT;
-       int i;
+       u_int i;
 
        if (strcmp(dev, "dbus-system") == 0) {
                if (!(handlep->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get system bus: %s", error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get system bus: %s", error.message);
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
        } else if (strcmp(dev, "dbus-session") == 0) {
                if (!(handlep->conn = dbus_bus_get(DBUS_BUS_SESSION, &error))) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get session bus: %s", error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to get session bus: %s", error.message);
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
@@ -183,19 +183,19 @@ dbus_activate(pcap_t *handle)
                const char *addr = dev + 7;
 
                if (!(handlep->conn = dbus_connection_open(addr, &error))) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to open connection to: %s: %s", addr, error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to open connection to: %s: %s", addr, error.message);
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
                if (!dbus_bus_register(handlep->conn, &error)) {
-                       snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to register bus %s: %s\n", addr, error.message);
+                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to register bus %s: %s\n", addr, error.message);
                        dbus_error_free(&error);
                        return PCAP_ERROR;
                }
 
        } else {
-               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't get bus address from %s", handle->opt.source);
+               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't get bus address from %s", handle->opt.device);
                return PCAP_ERROR;
        }
 
@@ -211,6 +211,7 @@ dbus_activate(pcap_t *handle)
        handle->getnonblock_op = pcap_getnonblock_fd;
        handle->setnonblock_op = pcap_setnonblock_fd;
        handle->stats_op = dbus_stats;
+       handle->cleanup_op = dbus_cleanup;
 
        handle->selectable_fd = handle->fd = -1;
 
@@ -222,6 +223,14 @@ dbus_activate(pcap_t *handle)
                return PCAP_ERROR_RFMON_NOTSUP;
        }
 
+       /*
+        * Turn a negative snapshot value (invalid), a snapshot value of
+        * 0 (unspecified), or a value bigger than the normal maximum
+        * value, into the maximum message length for D-Bus (128MB).
+        */
+       if (handle->snapshot <= 0 || handle->snapshot > 134217728)
+               handle->snapshot = 134217728;
+
        /* dbus_connection_set_max_message_size(handlep->conn, handle->snapshot); */
        if (handle->opt.buffer_size != 0)
                dbus_connection_set_max_received_size(handlep->conn, handle->opt.buffer_size);
@@ -234,7 +243,7 @@ dbus_activate(pcap_t *handle)
                        /* try without eavesdrop */
                        dbus_bus_add_match(handlep->conn, rules[i] + strlen(EAVESDROPPING_RULE), &error);
                        if (dbus_error_is_set(&error)) {
-                               snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to add bus match: %s\n", error.message);
+                               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Failed to add bus match: %s\n", error.message);
                                dbus_error_free(&error);
                                dbus_cleanup(handle);
                                return PCAP_ERROR;
@@ -250,8 +259,8 @@ dbus_create(const char *device, char *ebuf, int *is_ours)
 {
        pcap_t *p;
 
-       if (strcmp(device, "dbus-system") && 
-               strcmp(device, "dbus-session") && 
+       if (strcmp(device, "dbus-system") &&
+               strcmp(device, "dbus-session") &&
                strncmp(device, "dbus://", 7))
        {
                *is_ours = 0;
@@ -259,7 +268,7 @@ dbus_create(const char *device, char *ebuf, int *is_ours)
        }
 
        *is_ours = 1;
-       p = pcap_create_common(device, ebuf, sizeof (struct pcap_dbus));
+       p = pcap_create_common(ebuf, sizeof (struct pcap_dbus));
        if (p == NULL)
                return (NULL);
 
@@ -267,12 +276,12 @@ dbus_create(const char *device, char *ebuf, int *is_ours)
        return (p);
 }
 
-int 
-dbus_findalldevs(pcap_if_t **alldevsp, char *err_str)
+int
+dbus_findalldevs(pcap_if_list_t *devlistp, char *err_str)
 {
-       if (pcap_add_if(alldevsp, "dbus-system", 0, "D-Bus system bus", err_str) < 0)
+       if (add_dev(devlistp, "dbus-system", 0, "D-Bus system bus", err_str) == NULL)
                return -1;
-       if (pcap_add_if(alldevsp, "dbus-session", 0, "D-Bus session bus", err_str) < 0)
+       if (add_dev(devlistp, "dbus-session", 0, "D-Bus session bus", err_str) == NULL)
                return -1;
        return 0;
 }