pcap_create_interface() needs the interface name on Linux.

[libpcap] / pcap-dbus.c

diff --git a/pcap-dbus.c b/pcap-dbus.c
index 3a54d444b35ac4e036dd3ad095931fed64c36256..c5b80dee95fa2f4855f6f7b21a714ba5d4167e59 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
@@ -53,7 +53,7 @@ struct pcap_dbus {
 static int
 dbus_read(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
 {
-       struct pcap_dbus *handlep = handle->private;
+       struct pcap_dbus *handlep = handle->priv;
 
        struct pcap_pkthdr pkth;
        DBusMessage *message;
@@ -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;
        }
 
@@ -106,13 +106,13 @@ static int
 dbus_write(pcap_t *handle, const void *buf, size_t size)
 {
        /* XXX, not tested */
-       struct pcap_dbus *handlep = handle->private;
+       struct pcap_dbus *handlep = handle->priv;
 
        DBusError error = DBUS_ERROR_INIT;
        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,12 +122,12 @@ 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)
 {
-       struct pcap_dbus *handlep = handle->private;
+       struct pcap_dbus *handlep = handle->priv;
 
        stats->ps_recv = handlep->packets_read;
        stats->ps_drop = 0;
@@ -138,7 +138,7 @@ dbus_stats(pcap_t *handle, struct pcap_stat *stats)
 static void
 dbus_cleanup(pcap_t *handle)
 {
-       struct pcap_dbus *handlep = handle->private;
+       struct pcap_dbus *handlep = handle->priv;
 
        dbus_connection_unref(handlep->conn);
 
@@ -159,22 +159,22 @@ dbus_activate(pcap_t *handle)
 
        #define N_RULES sizeof(rules)/sizeof(rules[0])
 
-       struct pcap_dbus *handlep = handle->private;
-       const char *dev = handle->opt.source;
+       struct pcap_dbus *handlep = handle->priv;
+       const char *dev = handle->opt.device;
 
        DBusError error = DBUS_ERROR_INIT;
        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;
        }
 
@@ -234,7 +234,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 +250,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 +259,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,14 +267,12 @@ dbus_create(const char *device, char *ebuf, int *is_ours)
        return (p);
 }
 
-int 
+int
 dbus_findalldevs(pcap_if_t **alldevsp, char *err_str)
 {
-       pcap_if_t *found_dev = *alldevsp;
-
-       if (pcap_add_if(&found_dev, "dbus-system", 0, "D-Bus system bus", err_str) < 0)
+       if (pcap_add_if(alldevsp, "dbus-system", 0, "D-Bus system bus", err_str) < 0)
                return -1;
-       if (pcap_add_if(&found_dev, "dbus-session", 0, "D-Bus session bus", err_str) < 0)
+       if (pcap_add_if(alldevsp, "dbus-session", 0, "D-Bus session bus", err_str) < 0)
                return -1;
        return 0;
 }