hal: Branch 'master' - 3 commits

David Zeuthen david at kemper.freedesktop.org
Sat Mar 24 11:02:54 PDT 2007


 examples/mandatory-locking-test.py |   20 ++
 hald/device.c                      |  171 +++++++++++++++++++
 hald/device.h                      |    9 +
 hald/hald_dbus.c                   |  326 ++++++++++++++++++++++++++++++++++++-
 hald/hald_dbus.h                   |    4 
 tools/lshal.c                      |   23 +-
 6 files changed, 542 insertions(+), 11 deletions(-)

New commits:
diff-tree 0499ff730d61ac8e2991a8089ebc96dd10f95e43 (from da2f627fa4683728346df492b302697406bc9ac8)
Author: David Zeuthen <davidz at redhat.com>
Date:   Sat Mar 24 13:59:13 2007 -0400

    add named mandatory locking API
    
    This provides a mechanism for clients to acquire (and release) named
    locks on device objects. More than one client can hold a named lock on
    a device, this is by design. If a client disconnects from the bus, it
    locks will be removed.
    
    The rationale for this new API is to allow clients to lock out other
    clients of service on given device objects; this is applicable for
    
     - installers (inhibit mount requests)
    
     - partitioning/formatting tools (inhibit mount requests)
    
     - multi-seat power management (inhibit suspend/hibernate etc. requests
       from idle (e.g. the user is idle) active (e.g. it is in the foreground
       on some seat) sessions that wants to suspend due to user preferences.)
    
    The next series of patches will make the various mechanisms use this
    API by defining well-known locks.

diff --git a/examples/mandatory-locking-test.py b/examples/mandatory-locking-test.py
new file mode 100755
index 0000000..d863814
--- /dev/null
+++ b/examples/mandatory-locking-test.py
@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+
+import dbus
+import sys
+import time
+import os
+
+bus = dbus.Bus(dbus.Bus.TYPE_SYSTEM)
+device = dbus.Interface(bus.get_object("org.freedesktop.Hal",
+                                       "/org/freedesktop/Hal/devices/computer"),
+#                                       "/org/freedesktop/Hal/devices/volume_label_EOS_DIGITAL"),
+                        "org.freedesktop.Hal.Device")
+
+device.AcquireMandatoryLock("foo")
+device.AcquireMandatoryLock("foo2")
+time.sleep(2)
+device.ReleaseMandatoryLock("foo2")
+#device.ReleaseMandatoryLock("foo")
+time.sleep(2)
diff --git a/hald/device.c b/hald/device.c
index a9b67f8..81cfa91 100644
--- a/hald/device.c
+++ b/hald/device.c
@@ -37,6 +37,24 @@
 #include "logger.h"
 #include "hald_runner.h"
 
+static GSList *locked_devices = NULL;
+
+static void
+add_to_locked_set (HalDevice *device)
+{
+        if (g_slist_find (locked_devices, device) != NULL)
+                return;
+
+        locked_devices = g_slist_prepend (locked_devices, device);
+}
+
+
+static void
+remove_from_locked_set (HalDevice *device)
+{
+        locked_devices = g_slist_remove (locked_devices, device);
+}
+
 struct _HalProperty {
 	int type;
 	union {
@@ -374,6 +392,8 @@ hal_device_finalize (GObject *obj)
 
 	runner_device_finalized (device);
 
+        remove_from_locked_set (device);
+
 #ifdef HALD_MEMLEAK_DBG
 	dbg_hal_device_object_delta--;
 	printf ("************* in finalize for udi=%s\n", device->private->udi);
@@ -629,6 +649,29 @@ hal_device_property_get_strlist_length (
 		return 0;
 }
 
+gboolean
+hal_device_property_strlist_contains (HalDevice  *device,
+				      const char *key,
+				      const char *value)
+{
+	GSList *i;
+	GSList *elems;
+	gboolean ret;
+
+	ret = FALSE;
+
+	elems = hal_device_property_get_strlist (device, key);
+	for (i = elems; i != NULL; i = g_slist_next (i)) {
+		if (strcmp (i->data, value) == 0) {
+			ret = TRUE;
+			break;
+		}
+	}
+
+	return ret;
+}
+
+
 void
 hal_device_property_strlist_iter_init (HalDevice    *device,
 				       const char   *key,
@@ -1567,3 +1610,131 @@ hal_device_are_all_addons_ready (HalDevi
 		return FALSE;
 	}
 }
+
+/**
+ * hal_device_acquire_lock:
+ * @device: the device to acquire a lock on
+ * @lock_name: name of the lock
+ * @sender: the caller to acquire the lock
+ *
+ * Acquires a named lock on a device.
+ *
+ * Returns: FALSE if the caller already holds this lock. TRUE if the caller got the lock.
+ */
+gboolean
+hal_device_acquire_lock (HalDevice *device, const char *lock_name, const char *sender)
+{
+        gboolean ret;
+        char buf[256];
+
+        ret = FALSE;
+
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+	if (hal_device_property_strlist_contains (device, buf, sender)) {
+                /* already locked */
+                goto out;
+        }
+	hal_device_property_strlist_append (device, buf, sender);
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+	hal_device_property_set_bool (device, buf, TRUE);
+
+	hal_device_property_strlist_append (device, "info.named_locks", lock_name);
+
+        add_to_locked_set (device);
+
+        ret = TRUE;
+out:
+        return ret;
+}
+
+/**
+ * hal_device_release_lock:
+ * @device: the device to acquire a lock on
+ * @lock_name: name of the lock
+ * @sender: the caller to acquire the lock
+ *
+ * Releases a named lock on a device.
+ *
+ * Returns: FALSE if the caller didn't hold this lock. True if the lock was removed.
+ */
+gboolean
+hal_device_release_lock (HalDevice *device, const char *lock_name, const char *sender)
+{
+        gboolean ret;
+        char buf[256];
+
+        ret = FALSE;
+
+        HAL_INFO (("Removing lock '%s' from '%s'", lock_name, sender));
+
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+	if (!hal_device_property_get_bool (device, buf)) {
+                /* not locked */
+                goto out;
+	}
+
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+	if (!hal_device_property_strlist_contains (device, buf, sender)) {
+                /* not locked by sender */
+                goto out;
+	}
+
+	if (hal_device_property_get_strlist_length (device, buf) == 1) {
+                /* last one to hold the lock */
+		g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+		hal_device_property_remove (device, buf);
+		g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+		hal_device_property_remove (device, buf);
+
+                if (hal_device_property_get_strlist_length (device, "info.named_locks") == 1) {
+                        hal_device_property_remove (device, "info.named_locks");
+                        remove_from_locked_set (device);
+                } else {
+                        hal_device_property_strlist_remove (device, "info.named_locks", lock_name);
+                }
+	} else {
+                /* there are additional holders */
+		hal_device_property_strlist_remove (device, buf, sender);
+	}
+
+        ret = TRUE;
+
+out:
+        return ret;
+}
+
+/**
+ * hal_device_client_disconnected:
+ * @sender: the client that disconnected from the bus
+ *
+ * Will remove locks held by this client on locked devices. This is a
+ * static class method that affects all devices that are locked.
+ *
+ */
+void
+hal_device_client_disconnected (const char *sender)
+{
+        GSList *i;
+
+        HAL_INFO (("Removing locks from '%s'", sender));
+
+        for (i = locked_devices; i != NULL; i = g_slist_next (i)) {
+                HalDevice *device = i->data;
+                GSList *locks;
+                GSList *j;
+                GSList *k;
+
+                HAL_INFO (("Looking at udi '%s'", device->private->udi));
+
+                locks = hal_device_property_get_strlist (device, "info.named_locks");
+                for (j = locks; j != NULL; j = k) {
+                        char *lock_name = j->data;
+                        k = g_slist_next (j);
+
+                        HAL_INFO (("Lock '%s'", lock_name));
+
+                        hal_device_release_lock (device, lock_name, sender);
+                }
+        }
+}
+
diff --git a/hald/device.h b/hald/device.h
index 5bab299..774d3dc 100644
--- a/hald/device.h
+++ b/hald/device.h
@@ -136,6 +136,9 @@ const char   *hal_device_property_get_st
 						    guint index);
 guint         hal_device_property_get_strlist_length (HalDevice    *device,
 						      const char   *key);
+gboolean      hal_device_property_strlist_contains (HalDevice    *device,
+						    const char   *key,
+						    const char   *value);
 char        **hal_device_property_dup_strlist_as_strv (HalDevice    *device,
 						       const char   *key);
 
@@ -203,5 +206,11 @@ gboolean      hal_device_inc_num_ready_a
 
 gboolean      hal_device_are_all_addons_ready (HalDevice *device);
 
+gboolean      hal_device_acquire_lock (HalDevice *device, const char *lock_name, const char *sender);
+
+gboolean      hal_device_release_lock (HalDevice *device, const char *lock_name, const char *sender);
+
+/* static method */
+void          hal_device_client_disconnected (const char *sender);
 
 #endif /* DEVICE_H */
diff --git a/hald/hald_dbus.c b/hald/hald_dbus.c
index effcd44..b69cbb7 100644
--- a/hald/hald_dbus.c
+++ b/hald/hald_dbus.c
@@ -2072,6 +2072,291 @@ device_query_capability (DBusConnection 
 	return DBUS_HANDLER_RESULT_HANDLED;
 }
 
+#if 0
+/*  map: service name -> list of {lock_name, udi}
+ */
+static GHashTable *services_with_mlocks = NULL;
+
+typedef struct
+{
+	char *lock_name;
+	char *udi;
+} MLockEntry;
+
+static void
+free_mlock_entry (MLockEntry *me)
+{
+	g_free (me->lock_name);
+	g_free (me->udi);
+	g_free (me);
+}
+
+static MLockEntry *
+new_mlock_entry (const char *lock_name, const char *udi)
+{
+	MLockEntry *me;
+	me = g_new0 (MLockEntry, 1);
+	me->lock_name = g_strdup (lock_name);
+	me->udi = g_strdup (udi);
+	return me;
+}
+
+static void
+free_mlock_list (GSList *mlock_list)
+{
+	g_slist_foreach (mlock_list, (GFunc) free_mlock_entry, NULL);
+	g_slist_free (mlock_list);
+}
+
+static void
+print_mlock_per_service (const char *service, GSList *mlock_list, gpointer userdata)
+{
+	GSList *i;
+	HAL_INFO (("  mlocks for service %s", service));
+	for (i = mlock_list; i != NULL; i = g_slist_next (i)) {
+		MLockEntry *me = i->data;
+		HAL_INFO (("    lock_name=%s   udi=%s", me->lock_name, me->udi));
+	}
+}
+
+static void
+dump_mlocks (void)
+{
+	HAL_INFO (("--- Dumping mlocks"));
+	g_hash_table_foreach (services_with_mlocks, (GHFunc) print_mlock_per_service, NULL);
+	HAL_INFO (("------------------"));
+}
+#endif
+
+/**  
+ *  device_acquire_mandatory_lock:
+ *  @connection:         D-BUS connection
+ *  @message:            Message
+ * 
+ *  Returns:             What to do with the message
+ *
+ *  Acquire a named mandatory lock on a device.
+ *
+ *  <pre>
+ *  void Device.AcquireMandatoryLock(string lock_name)
+ *
+ *  raises org.freedesktop.Hal.NoSuchDevice, 
+ *        org.freedesktop.Hal.DeviceAlreadyLocked (if the caller already got a lock on the device with the given name)
+ *  </pre>
+ */
+DBusHandlerResult
+device_acquire_mandatory_lock (DBusConnection *connection, DBusMessage *message)
+{
+	const char *udi;
+	HalDevice *d;
+	DBusMessage *reply;
+	DBusError error;
+	char *lock_name;
+	const char *sender;
+
+	HAL_TRACE (("entering"));
+
+	udi = dbus_message_get_path (message);
+
+	d = hal_device_store_find (hald_get_gdl (), udi);
+	if (d == NULL)
+		d = hal_device_store_find (hald_get_tdl (), udi);
+
+	if (d == NULL) {
+		raise_no_such_device (connection, message, udi);
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	dbus_error_init (&error);
+	if (!dbus_message_get_args (message, &error,
+				    DBUS_TYPE_STRING, &lock_name,
+				    DBUS_TYPE_INVALID)) {
+		raise_syntax (connection, message, "AqcuireMandatoryLock");
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	sender = dbus_message_get_sender (message);
+
+        if (!hal_device_acquire_lock (d, lock_name, sender)) {
+		raise_device_already_locked (connection, message, d);
+		return DBUS_HANDLER_RESULT_HANDLED;
+        }
+
+	reply = dbus_message_new_method_return (message);
+	if (reply == NULL)
+		DIE (("No memory"));
+
+	if (!dbus_connection_send (connection, reply, NULL))
+		DIE (("No memory"));
+
+	dbus_message_unref (reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+
+#if 0
+	reply = dbus_message_new_method_return (message);
+	if (reply == NULL)
+		DIE (("No memory"));
+
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+	if (hal_device_property_strlist_contains (d, buf, sender)) {
+		raise_device_already_locked (connection, message, d);
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+	hal_device_property_strlist_append (d, buf, sender);
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+	hal_device_property_set_bool (d, buf, TRUE);
+
+	GSList *mlock_list;
+	if (services_with_mlocks == NULL) {
+		services_with_mlocks = g_hash_table_new_full (g_str_hash,
+							      g_str_equal,
+							      g_free,
+							      (GDestroyNotify) free_mlock_list);
+		mlock_list = g_slist_append (NULL, new_mlock_entry (lock_name, udi));
+		g_hash_table_insert (services_with_mlocks, g_strdup (sender), mlock_list);
+	} else {
+		mlock_list = g_hash_table_lookup (services_with_mlocks, sender);
+		if (mlock_list != NULL) {
+			/* head is guarenteed not to change */
+			g_slist_append (mlock_list, new_mlock_entry (lock_name, udi));
+		} else {
+			mlock_list = g_slist_append (NULL, new_mlock_entry (lock_name, udi));
+			g_hash_table_insert (services_with_mlocks, g_strdup (sender), mlock_list);
+		}
+	}
+	dump_mlocks ();
+
+	if (!dbus_connection_send (connection, reply, NULL))
+		DIE (("No memory"));
+
+	dbus_message_unref (reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+#endif
+
+
+/** 
+ *  device_release_mandatory_lock: 
+ *  @connection:         D-BUS connection
+ *  @message:            Message
+ *
+ *  Returns:             What to do with the message
+ *
+ *  Released a named mandatory lock on a device.
+ *
+ *  <pre>
+ *  void Device.ReleaseMandatoryLock(string lock_name)
+ *
+ *  raises org.freedesktop.Hal.NoSuchDevice, 
+ *         org.freedesktop.Hal.DeviceNotLocked (if the caller haven't a lock on the device with the given name)
+ *  </pre>
+ */
+DBusHandlerResult
+device_release_mandatory_lock (DBusConnection *connection, DBusMessage *message)
+{
+	const char *udi;
+	HalDevice *d;
+	DBusMessage *reply;
+	DBusError error;
+	const char *sender;
+	char *lock_name;
+
+	HAL_TRACE (("entering"));
+
+	udi = dbus_message_get_path (message);
+
+	d = hal_device_store_find (hald_get_gdl (), udi);
+	if (d == NULL)
+		d = hal_device_store_find (hald_get_tdl (), udi);
+
+	if (d == NULL) {
+		raise_no_such_device (connection, message, udi);
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	dbus_error_init (&error);
+	if (!dbus_message_get_args (message, &error,
+				    DBUS_TYPE_STRING, &lock_name,
+				    DBUS_TYPE_INVALID)) {
+		raise_syntax (connection, message, "ReleaseMandatoryLock");
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	sender = dbus_message_get_sender (message);
+
+        if (!hal_device_release_lock (d, lock_name, sender)) {
+		raise_device_already_locked (connection, message, d);
+		return DBUS_HANDLER_RESULT_HANDLED;
+        }
+
+	reply = dbus_message_new_method_return (message);
+	if (reply == NULL)
+		DIE (("No memory"));
+
+	if (!dbus_connection_send (connection, reply, NULL))
+		DIE (("No memory"));
+
+	dbus_message_unref (reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+#if 0
+	reply = dbus_message_new_method_return (message);
+	if (reply == NULL)
+		DIE (("No memory"));
+
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+	if (!hal_device_property_get_bool (d, buf)) {
+		raise_device_not_locked (connection, message, d);
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	sender = dbus_message_get_sender (message);
+
+	g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+	if (!hal_device_property_strlist_contains (d, buf, sender)) {
+		raise_permission_denied (connection, message, "Not locked by you");
+		return DBUS_HANDLER_RESULT_HANDLED;
+	}
+
+	if (hal_device_property_get_strlist_length (d, buf) == 1) {
+		g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+		hal_device_property_remove (d, buf);
+		g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+		hal_device_property_remove (d, buf);
+	} else {
+		hal_device_property_strlist_remove (d, buf, sender);
+	}
+
+	GSList *mlock_list;
+	mlock_list = g_hash_table_lookup (services_with_mlocks, sender);
+	if (mlock_list != NULL) {
+		GSList *i;
+		GSList *new_mlock_list = NULL;
+		for (i = mlock_list; i != NULL; i = g_slist_next (i)) {
+			MLockEntry *me = i->data;
+			if (!(strcmp (me->udi, udi) == 0 && strcmp (me->lock_name, lock_name) == 0)) {
+				new_mlock_list = g_slist_append (new_mlock_list, new_mlock_entry (lock_name, udi));
+			}
+		}
+		if (new_mlock_list != NULL)
+			g_hash_table_replace (services_with_mlocks, g_strdup (sender), new_mlock_list);
+		else
+			g_hash_table_remove (services_with_mlocks, sender);
+	}
+	dump_mlocks ();
+
+	if (!dbus_connection_send (connection, reply, NULL))
+		DIE (("No memory"));
+
+	dbus_message_unref (reply);
+	return DBUS_HANDLER_RESULT_HANDLED;
+}
+#endif
+
+/*------------------------------------------------------------------------*/
+
 static GHashTable *services_with_locks = NULL;
 
 /**  
@@ -3720,6 +4005,13 @@ do_introspect (DBusConnection  *connecti
 				       "      <arg name=\"released_lock\" direction=\"out\" type=\"b\"/>\n"
 				       "    </method>\n"
 
+				       "    <method name=\"AcquireMandatoryLock\">\n"
+				       "      <arg name=\"lock_name\" direction=\"in\" type=\"s\"/>\n"
+				       "    </method>\n"
+				       "    <method name=\"ReleaseMandatoryLock\">\n"
+				       "      <arg name=\"lock_name\" direction=\"in\" type=\"s\"/>\n"
+				       "    </method>\n"
+
 				       "    <method name=\"StringListAppend\">\n"
 				       "      <arg name=\"key\" direction=\"in\" type=\"s\"/>\n"
 				       "      <arg name=\"value\" direction=\"in\" type=\"s\"/>\n"
@@ -4037,6 +4329,14 @@ hald_dbus_filter_handle_methods (DBusCon
 		return device_unlock (connection, message);
 	} else if (dbus_message_is_method_call (message,
 						"org.freedesktop.Hal.Device",
+						"AcquireMandatoryLock")) {
+		return device_acquire_mandatory_lock (connection, message);
+	} else if (dbus_message_is_method_call (message,
+						"org.freedesktop.Hal.Device",
+						"ReleaseMandatoryLock")) {
+		return device_release_mandatory_lock (connection, message);
+	} else if (dbus_message_is_method_call (message,
+						"org.freedesktop.Hal.Device",
 						"StringListAppend")) {
 		return device_string_list_append_prepend (connection, message, FALSE);
 	} else if (dbus_message_is_method_call (message,
@@ -4295,6 +4595,30 @@ hald_dbus_filter_function (DBusConnectio
 			}
 		}
 
+                if (strlen (old_service_name) > 0)
+                        hal_device_client_disconnected (old_service_name);
+#if 0
+		if (services_with_mlocks != NULL) {
+			GSList *i;
+			GSList *mlock_list;
+			mlock_list = g_hash_table_lookup (services_with_mlocks, new_service_name);
+			for (i = mlock_list; i != NULL; i = g_slist_next (i)) {
+#if 0
+				if (hal_device_property_get_strlist_length (d, buf) == 1) {
+					g_snprintf (buf, sizeof (buf), "info.named_locks.%s.locked", lock_name);
+					hal_device_property_remove (d, buf);
+					g_snprintf (buf, sizeof (buf), "info.named_locks.%s.dbus_name", lock_name);
+					hal_device_property_remove (d, buf);
+				} else {
+					hal_device_property_strlist_remove (d, buf, sender);
+				}
+#endif				
+			}
+			g_hash_table_remove (services_with_mlocks, new_service_name);
+			dump_mlocks ();
+		}
+#endif
+
 #ifdef HAVE_CONKIT
 	} else if (dbus_message_is_signal (message,
 					   "org.freedesktop.ConsoleKit.Session",
diff --git a/hald/hald_dbus.h b/hald/hald_dbus.h
index d7f9acc..3fba19d 100644
--- a/hald/hald_dbus.h
+++ b/hald/hald_dbus.h
@@ -64,6 +64,10 @@ DBusHandlerResult device_lock           
 						     DBusMessage    *message);
 DBusHandlerResult device_unlock                     (DBusConnection *connection,
 						     DBusMessage    *message);
+DBusHandlerResult device_acquire_mandatory_lock     (DBusConnection *connection, 
+						     DBusMessage *message);
+DBusHandlerResult device_release_mandatory_lock     (DBusConnection *connection, 
+						     DBusMessage *message);
 DBusHandlerResult manager_new_device          (DBusConnection *connection,
 					       DBusMessage    *message, 
 					       dbus_bool_t    local_interface);
diff-tree da2f627fa4683728346df492b302697406bc9ac8 (from a98d7e20b41469dc43e67842d45a45c26ebf2c2e)
Author: David Zeuthen <davidz at redhat.com>
Date:   Sat Mar 24 13:52:32 2007 -0400

    fix segfault in lshal where strlist prop was removed just after it changed

diff --git a/tools/lshal.c b/tools/lshal.c
index 372c2f5..0951657 100644
--- a/tools/lshal.c
+++ b/tools/lshal.c
@@ -480,16 +480,19 @@ print_property (const char *udi, const c
 			printf ("{");
 
 		strlist = libhal_device_get_property_strlist (hal_ctx, udi, key, &error);
-		for (i = 0; strlist[i] != 0; i++) {
-			printf ("'%s'", strlist[i]);
-			if (strlist[i+1] != NULL)
-				printf (", ");
-		}
-		if (long_list)
-			printf ("}  (string list)\n");
-		else
-			printf ("}");
-		libhal_free_string_array (strlist);
+                /* may be NULL because property may have been removed */
+                if (strlist != NULL) {
+                        for (i = 0; strlist[i] != 0; i++) {
+                                printf ("'%s'", strlist[i]);
+                                if (strlist[i+1] != NULL)
+                                        printf (", ");
+                        }
+                        if (long_list)
+                                printf ("}  (string list)\n");
+                        else
+                                printf ("}");
+                        libhal_free_string_array (strlist);
+                }
 		break;
 	}
 
diff-tree a98d7e20b41469dc43e67842d45a45c26ebf2c2e (from fca55ae474f6d3736a190741e222b2cd1a91322d)
Author: David Zeuthen <davidz at redhat.com>
Date:   Sat Mar 24 12:20:34 2007 -0400

    avoid logging when client asks for non-existant property

diff --git a/hald/hald_dbus.c b/hald/hald_dbus.c
index 95001d2..effcd44 100644
--- a/hald/hald_dbus.c
+++ b/hald/hald_dbus.c
@@ -88,7 +88,7 @@ raise_error (DBusConnection *connection,
 	vsnprintf(buf, sizeof buf, format, args);
 	va_end(args);
 
-	HAL_WARNING ((buf));
+	/*HAL_WARNING ((buf));*/
 	reply = dbus_message_new_error (in_reply_to, error_name, buf);
 	if (reply == NULL)
 		DIE (("No memory"));


More information about the hal-commit mailing list