File: libhal.xml

package info (click to toggle)
hal 0.5.14-3
links: PTS, VCS
area: main
in suites: squeeze
size: 10,212 kB
ctags: 4,854
sloc: ansic: 60,732; xml: 16,387; sh: 11,366; makefile: 1,111; cpp: 292
file content (3026 lines) | stat: -rw-r--r-- 223,819 bytes
parent folder | download | duplicates (2)
<?xml version="1.0"?>
<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
               "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY version SYSTEM "version.xml">
]>
<refentry id="libhal-libhal">
<refmeta>
<refentrytitle role="top_of_page" id="libhal-libhal.top_of_page">libhal</refentrytitle>
<manvolnum>3</manvolnum>
<refmiscinfo>LIBHAL Library</refmiscinfo>
</refmeta>

<refnamediv>
<refname>libhal</refname>
<refpurpose></refpurpose>
</refnamediv>

<refsynopsisdiv id="libhal-libhal.synopsis" role="synopsis">
<title role="synopsis.title">Synopsis</title>

<synopsis>
#define             <link linkend="DBUS-API-SUBJECT-TO-CHANGE--CAPS">DBUS_API_SUBJECT_TO_CHANGE</link>
#define             <link linkend="LIBHAL-DEPRECATED--CAPS">LIBHAL_DEPRECATED</link>
#define             <link linkend="LIBHAL-FREE-DBUS-ERROR--CAPS">LIBHAL_FREE_DBUS_ERROR</link>              (_dbus_error_)
#define             <link linkend="LIBHAL-CHECK-LIBHALCONTEXT--CAPS">LIBHAL_CHECK_LIBHALCONTEXT</link>          (_ctx_, _ret_)
enum                <link linkend="LibHalPropertyType">LibHalPropertyType</link>;
typedef             <link linkend="LibHalContext">LibHalContext</link>;
typedef             <link linkend="LibHalProperty">LibHalProperty</link>;
typedef             <link linkend="LibHalPropertySet">LibHalPropertySet</link>;
<link linkend="void">void</link>                (<link linkend="LibHalIntegrateDBusIntoMainLoop">*LibHalIntegrateDBusIntoMainLoop</link>)  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusConnection">DBusConnection</link> *dbus_connection);
<link linkend="void">void</link>                (<link linkend="LibHalDeviceAdded">*LibHalDeviceAdded</link>)                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi);
<link linkend="void">void</link>                (<link linkend="LibHalDeviceRemoved">*LibHalDeviceRemoved</link>)              (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi);
<link linkend="void">void</link>                (<link linkend="LibHalDeviceNewCapability">*LibHalDeviceNewCapability</link>)        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability);
<link linkend="void">void</link>                (<link linkend="LibHalDeviceLostCapability">*LibHalDeviceLostCapability</link>)       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability);
<link linkend="void">void</link>                (<link linkend="LibHalDevicePropertyModified">*LibHalDevicePropertyModified</link>)     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> is_removed,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> is_added);
<link linkend="void">void</link>                (<link linkend="LibHalDeviceCondition">*LibHalDeviceCondition</link>)            (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *condition_name,
                                                         const <link linkend="char">char</link> *condition_detail);
<link linkend="void">void</link>                (<link linkend="LibHalGlobalInterfaceLockAcquired">*LibHalGlobalInterfaceLockAcquired</link>)
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);
<link linkend="void">void</link>                (<link linkend="LibHalGlobalInterfaceLockReleased">*LibHalGlobalInterfaceLockReleased</link>)
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);
<link linkend="void">void</link>                (<link linkend="LibHalInterfaceLockAcquired">*LibHalInterfaceLockAcquired</link>)      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);
<link linkend="void">void</link>                (<link linkend="LibHalInterfaceLockReleased">*LibHalInterfaceLockReleased</link>)      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);
<link linkend="void">void</link>                (<link linkend="LibHalSingletonDeviceAdded">*LibHalSingletonDeviceAdded</link>)       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *properties);
<link linkend="void">void</link>                (<link linkend="LibHalSingletonDeviceRemoved">*LibHalSingletonDeviceRemoved</link>)     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *properties);
<link linkend="LibHalContext">LibHalContext</link> *     <link linkend="libhal-ctx-new">libhal_ctx_new</link>                      (void);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-cache">libhal_ctx_set_cache</link>                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> use_cache);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-dbus-connection">libhal_ctx_set_dbus_connection</link>      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusConnection">DBusConnection</link> *conn);
<link linkend="DBusConnection">DBusConnection</link> *    <link linkend="libhal-ctx-get-dbus-connection">libhal_ctx_get_dbus_connection</link>      (<link linkend="LibHalContext">LibHalContext</link> *ctx);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-user-data">libhal_ctx_set_user_data</link>            (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="void">void</link> *user_data);
<link linkend="void">void</link>*               <link linkend="libhal-ctx-get-user-data">libhal_ctx_get_user_data</link>            (<link linkend="LibHalContext">LibHalContext</link> *ctx);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-device-added">libhal_ctx_set_device_added</link>         (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceAdded">LibHalDeviceAdded</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-device-removed">libhal_ctx_set_device_removed</link>       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceRemoved">LibHalDeviceRemoved</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-device-new-capability">libhal_ctx_set_device_new_capability</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceNewCapability">LibHalDeviceNewCapability</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-device-lost-capability">libhal_ctx_set_device_lost_capability</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceLostCapability">LibHalDeviceLostCapability</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-device-property-modified">libhal_ctx_set_device_property_modified</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDevicePropertyModified">LibHalDevicePropertyModified</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-device-condition">libhal_ctx_set_device_condition</link>     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceCondition">LibHalDeviceCondition</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-global-interface-lock-acquired">libhal_ctx_set_global_interface_lock_acquired</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalGlobalInterfaceLockAcquired">LibHalGlobalInterfaceLockAcquired</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-global-interface-lock-released">libhal_ctx_set_global_interface_lock_released</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalGlobalInterfaceLockReleased">LibHalGlobalInterfaceLockReleased</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-interface-lock-acquired">libhal_ctx_set_interface_lock_acquired</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalInterfaceLockAcquired">LibHalInterfaceLockAcquired</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-interface-lock-released">libhal_ctx_set_interface_lock_released</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalInterfaceLockReleased">LibHalInterfaceLockReleased</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-singleton-device-added">libhal_ctx_set_singleton_device_added</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalSingletonDeviceAdded">LibHalSingletonDeviceAdded</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-set-singleton-device-removed">libhal_ctx_set_singleton_device_removed</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalSingletonDeviceRemoved">LibHalSingletonDeviceRemoved</link> callback);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-init">libhal_ctx_init</link>                     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-shutdown">libhal_ctx_shutdown</link>                 (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ctx-free">libhal_ctx_free</link>                     (<link linkend="LibHalContext">LibHalContext</link> *ctx);
<link linkend="LibHalContext">LibHalContext</link> *     <link linkend="libhal-ctx-init-direct">libhal_ctx_init_direct</link>              (<link linkend="DBusError">DBusError</link> *error);
<link linkend="char">char</link> **             <link linkend="libhal-get-all-devices">libhal_get_all_devices</link>              (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="int">int</link> *num_devices,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-exists">libhal_device_exists</link>                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-print">libhal_device_print</link>                 (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-exists">libhal_device_property_exists</link>       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="char">char</link> *              <link linkend="libhal-device-get-property-string">libhal_device_get_property_string</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-int32-t">dbus_int32_t</link>        <link linkend="libhal-device-get-property-int">libhal_device_get_property_int</link>      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-uint64-t">dbus_uint64_t</link>       <link linkend="libhal-device-get-property-uint64">libhal_device_get_property_uint64</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="double">double</link>              <link linkend="libhal-device-get-property-double">libhal_device_get_property_double</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-get-property-bool">libhal_device_get_property_bool</link>     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="char">char</link> **             <link linkend="libhal-device-get-property-strlist">libhal_device_get_property_strlist</link>  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-set-property-string">libhal_device_set_property_string</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-set-property-int">libhal_device_set_property_int</link>      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-int32-t">dbus_int32_t</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-set-property-uint64">libhal_device_set_property_uint64</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-uint64-t">dbus_uint64_t</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-set-property-double">libhal_device_set_property_double</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="double">double</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-set-property-bool">libhal_device_set_property_bool</link>     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-strlist-append">libhal_device_property_strlist_append</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-strlist-prepend">libhal_device_property_strlist_prepend</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-strlist-remove-index">libhal_device_property_strlist_remove_index</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         unsigned <link linkend="int">int</link> idx,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-strlist-remove">libhal_device_property_strlist_remove</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-remove-property">libhal_device_remove_property</link>       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="LibHalPropertyType">LibHalPropertyType</link>  <link linkend="libhal-device-get-property-type">libhal_device_get_property_type</link>     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);
struct              <link linkend="LibHalChangeSet-s">LibHalChangeSet_s</link>;
typedef             <link linkend="LibHalChangeSet">LibHalChangeSet</link>;
<link linkend="LibHalChangeSet">LibHalChangeSet</link> *   <link linkend="libhal-device-new-changeset">libhal_device_new_changeset</link>         (const <link linkend="char">char</link> *udi);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-changeset-set-property-string">libhal_changeset_set_property_string</link>
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-changeset-set-property-int">libhal_changeset_set_property_int</link>   (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-int32-t">dbus_int32_t</link> value);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-changeset-set-property-uint64">libhal_changeset_set_property_uint64</link>
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-uint64-t">dbus_uint64_t</link> value);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-changeset-set-property-double">libhal_changeset_set_property_double</link>
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="double">double</link> value);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-changeset-set-property-bool">libhal_changeset_set_property_bool</link>  (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> value);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-changeset-set-property-strlist">libhal_changeset_set_property_strlist</link>
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> **value);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-commit-changeset">libhal_device_commit_changeset</link>      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="void">void</link>                <link linkend="libhal-device-free-changeset">libhal_device_free_changeset</link>        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset);
<link linkend="LibHalPropertySet">LibHalPropertySet</link> * <link linkend="libhal-device-get-all-properties">libhal_device_get_all_properties</link>    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-get-all-devices-with-properties">libhal_get_all_devices_with_properties</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="int">int</link> *out_num_devices,
                                                         <link linkend="char">char</link> ***out_udi,
                                                         <link linkend="LibHalPropertySet">LibHalPropertySet</link> ***out_properties,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="void">void</link>                <link linkend="libhal-property-set-sort">libhal_property_set_sort</link>            (<link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);
<link linkend="void">void</link>                <link linkend="libhal-free-property-set">libhal_free_property_set</link>            (<link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);
unsigned <link linkend="int">int</link>        <link linkend="libhal-property-set-get-num-elems">libhal_property_set_get_num_elems</link>   (<link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);
<link linkend="LibHalPropertyType">LibHalPropertyType</link>  <link linkend="libhal-ps-get-type">libhal_ps_get_type</link>                  (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);
const <link linkend="char">char</link> *        <link linkend="libhal-ps-get-string">libhal_ps_get_string</link>                (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);
<link linkend="dbus-int32-t">dbus_int32_t</link>        <link linkend="libhal-ps-get-int32">libhal_ps_get_int32</link>                 (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);
<link linkend="dbus-uint64-t">dbus_uint64_t</link>       <link linkend="libhal-ps-get-uint64">libhal_ps_get_uint64</link>                (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);
<link linkend="double">double</link>              <link linkend="libhal-ps-get-double">libhal_ps_get_double</link>                (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-ps-get-bool">libhal_ps_get_bool</link>                  (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);
typedef             <link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link>;
<link linkend="void">void</link>                <link linkend="libhal-psi-init">libhal_psi_init</link>                     (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter,
                                                         <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-psi-has-more">libhal_psi_has_more</link>                 (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="void">void</link>                <link linkend="libhal-psi-next">libhal_psi_next</link>                     (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="LibHalPropertyType">LibHalPropertyType</link>  <link linkend="libhal-psi-get-type">libhal_psi_get_type</link>                 (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="char">char</link> *              <link linkend="libhal-psi-get-key">libhal_psi_get_key</link>                  (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="char">char</link> *              <link linkend="libhal-psi-get-string">libhal_psi_get_string</link>               (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="dbus-int32-t">dbus_int32_t</link>        <link linkend="libhal-psi-get-int">libhal_psi_get_int</link>                  (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="dbus-uint64-t">dbus_uint64_t</link>       <link linkend="libhal-psi-get-uint64">libhal_psi_get_uint64</link>               (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="double">double</link>              <link linkend="libhal-psi-get-double">libhal_psi_get_double</link>               (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-psi-get-bool">libhal_psi_get_bool</link>                 (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
<link linkend="char">char</link> **             <link linkend="libhal-psi-get-strlist">libhal_psi_get_strlist</link>              (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);
unsigned <link linkend="int">int</link>        <link linkend="libhal-string-array-length">libhal_string_array_length</link>          (<link linkend="char">char</link> **str_array);
<link linkend="void">void</link>                <link linkend="libhal-free-string-array">libhal_free_string_array</link>            (<link linkend="char">char</link> **str_array);
<link linkend="void">void</link>                <link linkend="libhal-free-string">libhal_free_string</link>                  (<link linkend="char">char</link> *str);
<link linkend="char">char</link> *              <link linkend="libhal-new-device">libhal_new_device</link>                   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-commit-to-gdl">libhal_device_commit_to_gdl</link>         (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *temp_udi,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-remove-device">libhal_remove_device</link>                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-merge-properties">libhal_merge_properties</link>             (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *target_udi,
                                                         const <link linkend="char">char</link> *source_udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-matches">libhal_device_matches</link>               (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi1,
                                                         const <link linkend="char">char</link> *udi2,
                                                         const <link linkend="char">char</link> *property_namespace,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="char">char</link> **             <link linkend="libhal-manager-find-device-string-match">libhal_manager_find_device_string_match</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="int">int</link> *num_devices,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-add-capability">libhal_device_add_capability</link>        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-query-capability">libhal_device_query_capability</link>      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="char">char</link> **             <link linkend="libhal-find-device-by-capability">libhal_find_device_by_capability</link>    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *capability,
                                                         <link linkend="int">int</link> *num_devices,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-watch-all">libhal_device_property_watch_all</link>    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-property-remove-watch-all">libhal_device_property_remove_watch_all</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-add-property-watch">libhal_device_add_property_watch</link>    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-remove-property-watch">libhal_device_remove_property_watch</link> (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-lock">libhal_device_lock</link>                  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *reason_to_lock,
                                                         <link linkend="char">char</link> **reason_why_locked,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-unlock">libhal_device_unlock</link>                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-rescan">libhal_device_rescan</link>                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-reprobe">libhal_device_reprobe</link>               (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-emit-condition">libhal_device_emit_condition</link>        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *condition_name,
                                                         const <link linkend="char">char</link> *condition_details,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-claim-interface">libhal_device_claim_interface</link>       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *introspection_xml,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-addon-is-ready">libhal_device_addon_is_ready</link>        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-singleton-addon-is-ready">libhal_device_singleton_addon_is_ready</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *command_line,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-acquire-interface-lock">libhal_device_acquire_interface_lock</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> exclusive,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-release-interface-lock">libhal_device_release_interface_lock</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-acquire-global-interface-lock">libhal_acquire_global_interface_lock</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> exclusive,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-release-global-interface-lock">libhal_release_global_interface_lock</link>
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-is-caller-locked-out">libhal_device_is_caller_locked_out</link>  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         const <link linkend="char">char</link> *caller,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="dbus-bool-t">dbus_bool_t</link>         <link linkend="libhal-device-is-locked-by-others">libhal_device_is_locked_by_others</link>   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="DBusError">DBusError</link> *error);
<link linkend="char">char</link>*               <link linkend="libhal-device-is-caller-privileged">libhal_device_is_caller_privileged</link>  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *action,
                                                         const <link linkend="char">char</link> *caller,
                                                         <link linkend="DBusError">DBusError</link> *error);
</synopsis>
</refsynopsisdiv>









<refsect1 id="libhal-libhal.description" role="desc">
<title role="desc.title">Description</title>
<para>
</para>
</refsect1>

<refsect1 id="libhal-libhal.details" role="details">
<title role="details.title">Details</title>
<refsect2 id="DBUS-API-SUBJECT-TO-CHANGE--CAPS" role="macro">
<title>DBUS_API_SUBJECT_TO_CHANGE</title>
<indexterm zone="DBUS-API-SUBJECT-TO-CHANGE--CAPS"><primary sortas="DBUS_API_SUBJECT_TO_CHANGE">DBUS_API_SUBJECT_TO_CHANGE</primary></indexterm><programlisting>#define DBUS_API_SUBJECT_TO_CHANGE 
</programlisting>
<para>
</para></refsect2>
<refsect2 id="LIBHAL-DEPRECATED--CAPS" role="macro">
<title>LIBHAL_DEPRECATED</title>
<indexterm zone="LIBHAL-DEPRECATED--CAPS"><primary sortas="LIBHAL_DEPRECATED">LIBHAL_DEPRECATED</primary></indexterm><programlisting>#define             LIBHAL_DEPRECATED</programlisting>
<para>
</para></refsect2>
<refsect2 id="LIBHAL-FREE-DBUS-ERROR--CAPS" role="macro">
<title>LIBHAL_FREE_DBUS_ERROR()</title>
<indexterm zone="LIBHAL-FREE-DBUS-ERROR--CAPS"><primary sortas="LIBHAL_FREE_DBUS_ERROR">LIBHAL_FREE_DBUS_ERROR</primary></indexterm><programlisting>#define             LIBHAL_FREE_DBUS_ERROR(_dbus_error_)</programlisting>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>_dbus_error_</parameter>&#160;:</term>
<listitem><simpara>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LIBHAL-CHECK-LIBHALCONTEXT--CAPS" role="macro">
<title>LIBHAL_CHECK_LIBHALCONTEXT()</title>
<indexterm zone="LIBHAL-CHECK-LIBHALCONTEXT--CAPS"><primary sortas="LIBHAL_CHECK_LIBHALCONTEXT">LIBHAL_CHECK_LIBHALCONTEXT</primary></indexterm><programlisting>#define             LIBHAL_CHECK_LIBHALCONTEXT(_ctx_, _ret_)</programlisting>
<para>
Handy macro for checking whether a context is valid.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>_ctx_</parameter>&#160;:</term>
<listitem><simpara> the context
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>_ret_</parameter>&#160;:</term>
<listitem><simpara> what to use for return value if context is invalid
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalPropertyType" role="enum">
<title>enum LibHalPropertyType</title>
<indexterm zone="LibHalPropertyType"><primary sortas="LibHalPropertyType">LibHalPropertyType</primary></indexterm><programlisting>typedef enum {
        /** Used to report error condition */
	LIBHAL_PROPERTY_TYPE_INVALID =    DBUS_TYPE_INVALID,

	/** Type for 32-bit signed integer property */
	LIBHAL_PROPERTY_TYPE_INT32   =    DBUS_TYPE_INT32,

	/** Type for 64-bit unsigned integer property */
	LIBHAL_PROPERTY_TYPE_UINT64  =    DBUS_TYPE_UINT64,

	/** Type for double precision floating point property */
	LIBHAL_PROPERTY_TYPE_DOUBLE  =    DBUS_TYPE_DOUBLE,

	/** Type for boolean property */
	LIBHAL_PROPERTY_TYPE_BOOLEAN =    DBUS_TYPE_BOOLEAN,

	/** Type for UTF-8 string property */
	LIBHAL_PROPERTY_TYPE_STRING  =    DBUS_TYPE_STRING,

	/** Type for list of UTF-8 strings property */
	LIBHAL_PROPERTY_TYPE_STRLIST =    ((int) (DBUS_TYPE_STRING&lt;&lt;8)+('l'))
} LibHalPropertyType;
</programlisting>
<para>
Possible types for properties on hal device objects</para>
<para>
</para></refsect2>
<refsect2 id="LibHalContext" role="typedef">
<title>LibHalContext</title>
<indexterm zone="LibHalContext"><primary sortas="LibHalContext">LibHalContext</primary></indexterm><programlisting>typedef struct LibHalContext_s LibHalContext;
</programlisting>
<para>
Context for connection to the HAL daemon. Opaque, use the
libhal_ctx_*() family of functions to access it.</para>
<para>
</para></refsect2>
<refsect2 id="LibHalProperty" role="typedef">
<title>LibHalProperty</title>
<indexterm zone="LibHalProperty"><primary sortas="LibHalProperty">LibHalProperty</primary></indexterm><programlisting>typedef struct LibHalProperty_s LibHalProperty;
</programlisting>
<para>
Represents a property. Opaque.</para>
<para>
</para></refsect2>
<refsect2 id="LibHalPropertySet" role="typedef">
<title>LibHalPropertySet</title>
<indexterm zone="LibHalPropertySet"><primary sortas="LibHalPropertySet">LibHalPropertySet</primary></indexterm><programlisting>typedef struct LibHalPropertySet_s LibHalPropertySet;
</programlisting>
<para>
Represents a set of properties. Opaque; use the
libhal_property_set_*() family of functions to access it.</para>
<para>
</para></refsect2>
<refsect2 id="LibHalIntegrateDBusIntoMainLoop" role="function">
<title>LibHalIntegrateDBusIntoMainLoop ()</title>
<indexterm zone="LibHalIntegrateDBusIntoMainLoop"><primary sortas="LibHalIntegrateDBusIntoMainLoop">LibHalIntegrateDBusIntoMainLoop</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalIntegrateDBusIntoMainLoop)  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusConnection">DBusConnection</link> *dbus_connection);</programlisting>
<para>
Type for function in application code that integrates a
DBusConnection object into its own mainloop.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>dbus_connection</parameter>&#160;:</term>
<listitem><simpara> DBus connection to use in ctx
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalDeviceAdded" role="function">
<title>LibHalDeviceAdded ()</title>
<indexterm zone="LibHalDeviceAdded"><primary sortas="LibHalDeviceAdded">LibHalDeviceAdded</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalDeviceAdded)                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi);</programlisting>
<para>
Type for callback when a device is added.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalDeviceRemoved" role="function">
<title>LibHalDeviceRemoved ()</title>
<indexterm zone="LibHalDeviceRemoved"><primary sortas="LibHalDeviceRemoved">LibHalDeviceRemoved</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalDeviceRemoved)              (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi);</programlisting>
<para>
Type for callback when a device is removed.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalDeviceNewCapability" role="function">
<title>LibHalDeviceNewCapability ()</title>
<indexterm zone="LibHalDeviceNewCapability"><primary sortas="LibHalDeviceNewCapability">LibHalDeviceNewCapability</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalDeviceNewCapability)        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability);</programlisting>
<para>
Type for callback when a device gains a new capability.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>capability</parameter>&#160;:</term>
<listitem><simpara> capability of the device
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalDeviceLostCapability" role="function">
<title>LibHalDeviceLostCapability ()</title>
<indexterm zone="LibHalDeviceLostCapability"><primary sortas="LibHalDeviceLostCapability">LibHalDeviceLostCapability</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalDeviceLostCapability)       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability);</programlisting>
<para>
Type for callback when a device loses a capability.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>capability</parameter>&#160;:</term>
<listitem><simpara> capability of the device
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalDevicePropertyModified" role="function">
<title>LibHalDevicePropertyModified ()</title>
<indexterm zone="LibHalDevicePropertyModified"><primary sortas="LibHalDevicePropertyModified">LibHalDevicePropertyModified</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalDevicePropertyModified)     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> is_removed,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> is_added);</programlisting>
<para>
Type for callback when a property of a device changes.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property that has changed
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>is_removed</parameter>&#160;:</term>
<listitem><simpara> whether or not property was removed
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>is_added</parameter>&#160;:</term>
<listitem><simpara> whether or not property was added
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalDeviceCondition" role="function">
<title>LibHalDeviceCondition ()</title>
<indexterm zone="LibHalDeviceCondition"><primary sortas="LibHalDeviceCondition">LibHalDeviceCondition</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalDeviceCondition)            (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *condition_name,
                                                         const <link linkend="char">char</link> *condition_detail);</programlisting>
<para>
Type for callback when a non-continuous condition occurs on a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>condition_name</parameter>&#160;:</term>
<listitem><simpara> name of the condition, e.g. ProcessorOverheating. Consult the HAL spec for details
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>condition_detail</parameter>&#160;:</term>
<listitem><simpara> detail of condition
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalGlobalInterfaceLockAcquired" role="function">
<title>LibHalGlobalInterfaceLockAcquired ()</title>
<indexterm zone="LibHalGlobalInterfaceLockAcquired"><primary sortas="LibHalGlobalInterfaceLockAcquired">LibHalGlobalInterfaceLockAcquired</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalGlobalInterfaceLockAcquired)
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);</programlisting>
<para>
Type for callback when someone acquires a global lock.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface_name</parameter>&#160;:</term>
<listitem><simpara> the name of the interface
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>lock_owner</parameter>&#160;:</term>
<listitem><simpara> what service acquired the lock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_locks</parameter>&#160;:</term>
<listitem><simpara> number of locks on the interface
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalGlobalInterfaceLockReleased" role="function">
<title>LibHalGlobalInterfaceLockReleased ()</title>
<indexterm zone="LibHalGlobalInterfaceLockReleased"><primary sortas="LibHalGlobalInterfaceLockReleased">LibHalGlobalInterfaceLockReleased</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalGlobalInterfaceLockReleased)
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);</programlisting>
<para>
Type for callback when someone releases a global lock.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface_name</parameter>&#160;:</term>
<listitem><simpara> the name of the interface
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>lock_owner</parameter>&#160;:</term>
<listitem><simpara> what service released the lock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_locks</parameter>&#160;:</term>
<listitem><simpara> number of locks on the interface
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalInterfaceLockAcquired" role="function">
<title>LibHalInterfaceLockAcquired ()</title>
<indexterm zone="LibHalInterfaceLockAcquired"><primary sortas="LibHalInterfaceLockAcquired">LibHalInterfaceLockAcquired</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalInterfaceLockAcquired)      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);</programlisting>
<para>
Type for callback when someone acquires a lock on a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface_name</parameter>&#160;:</term>
<listitem><simpara> the name of the interface
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>lock_owner</parameter>&#160;:</term>
<listitem><simpara> what service acquired the lock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_locks</parameter>&#160;:</term>
<listitem><simpara> number of locks on the interface
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalInterfaceLockReleased" role="function">
<title>LibHalInterfaceLockReleased ()</title>
<indexterm zone="LibHalInterfaceLockReleased"><primary sortas="LibHalInterfaceLockReleased">LibHalInterfaceLockReleased</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalInterfaceLockReleased)      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *lock_owner,
                                                         <link linkend="int">int</link> num_locks);</programlisting>
<para>
Type for callback when someone acquires a lock on a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface_name</parameter>&#160;:</term>
<listitem><simpara> the name of the interface
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>lock_owner</parameter>&#160;:</term>
<listitem><simpara> what service released the lock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_locks</parameter>&#160;:</term>
<listitem><simpara> number of locks on the interface
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalSingletonDeviceAdded" role="function">
<title>LibHalSingletonDeviceAdded ()</title>
<indexterm zone="LibHalSingletonDeviceAdded"><primary sortas="LibHalSingletonDeviceAdded">LibHalSingletonDeviceAdded</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalSingletonDeviceAdded)       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *properties);</programlisting>
<para>
Type for callback for addon singletons when a device is added</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>properties</parameter>&#160;:</term>
<listitem><simpara> the device's properties
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalSingletonDeviceRemoved" role="function">
<title>LibHalSingletonDeviceRemoved ()</title>
<indexterm zone="LibHalSingletonDeviceRemoved"><primary sortas="LibHalSingletonDeviceRemoved">LibHalSingletonDeviceRemoved</primary></indexterm><programlisting><link linkend="void">void</link>                (*LibHalSingletonDeviceRemoved)     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *properties);</programlisting>
<para>
Type for callback for addon singletons when a device is added</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context for connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>properties</parameter>&#160;:</term>
<listitem><simpara> the device's properties
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-new" role="function">
<title>libhal_ctx_new ()</title>
<indexterm zone="libhal-ctx-new"><primary sortas="libhal_ctx_new">libhal_ctx_new</primary></indexterm><programlisting><link linkend="LibHalContext">LibHalContext</link> *     libhal_ctx_new                      (void);</programlisting>
<para>
Create a new LibHalContext</para>
<para>
</para><variablelist role="params">
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> a new uninitialized LibHalContext object
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-cache" role="function">
<title>libhal_ctx_set_cache ()</title>
<indexterm zone="libhal-ctx-set-cache"><primary sortas="libhal_ctx_set_cache">libhal_ctx_set_cache</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_cache                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> use_cache);</programlisting>
<para>
Enable or disable caching. Note: Caching is not actually
implemented yet.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context to enable/disable cache for
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>use_cache</parameter>&#160;:</term>
<listitem><simpara> whether or not to use cache
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if cache was successfully enabled/disabled, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-dbus-connection" role="function">
<title>libhal_ctx_set_dbus_connection ()</title>
<indexterm zone="libhal-ctx-set-dbus-connection"><primary sortas="libhal_ctx_set_dbus_connection">libhal_ctx_set_dbus_connection</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_dbus_connection      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusConnection">DBusConnection</link> *conn);</programlisting>
<para>
Set DBus connection to use to talk to hald.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context to set connection for
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>conn</parameter>&#160;:</term>
<listitem><simpara> DBus connection to use
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if connection was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-get-dbus-connection" role="function">
<title>libhal_ctx_get_dbus_connection ()</title>
<indexterm zone="libhal-ctx-get-dbus-connection"><primary sortas="libhal_ctx_get_dbus_connection">libhal_ctx_get_dbus_connection</primary></indexterm><programlisting><link linkend="DBusConnection">DBusConnection</link> *    libhal_ctx_get_dbus_connection      (<link linkend="LibHalContext">LibHalContext</link> *ctx);</programlisting>
<para>
Get DBus connection used for talking to hald.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> context to get connection for
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> DBus connection to use or NULL
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-user-data" role="function">
<title>libhal_ctx_set_user_data ()</title>
<indexterm zone="libhal-ctx-set-user-data"><primary sortas="libhal_ctx_set_user_data">libhal_ctx_set_user_data</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_user_data            (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="void">void</link> *user_data);</programlisting>
<para>
Set user data for the context.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>user_data</parameter>&#160;:</term>
<listitem><simpara> user data
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if user data was successfully set, FALSE if otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-get-user-data" role="function">
<title>libhal_ctx_get_user_data ()</title>
<indexterm zone="libhal-ctx-get-user-data"><primary sortas="libhal_ctx_get_user_data">libhal_ctx_get_user_data</primary></indexterm><programlisting><link linkend="void">void</link>*               libhal_ctx_get_user_data            (<link linkend="LibHalContext">LibHalContext</link> *ctx);</programlisting>
<para>
Get user data for the context.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> opaque pointer stored through <link linkend="libhal-ctx-set-user-data"><function>libhal_ctx_set_user_data()</function></link> or NULL if not set.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-device-added" role="function">
<title>libhal_ctx_set_device_added ()</title>
<indexterm zone="libhal-ctx-set-device-added"><primary sortas="libhal_ctx_set_device_added">libhal_ctx_set_device_added</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_device_added         (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceAdded">LibHalDeviceAdded</link> callback);</programlisting>
<para>
Set the callback for when a device is added</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device is added
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-device-removed" role="function">
<title>libhal_ctx_set_device_removed ()</title>
<indexterm zone="libhal-ctx-set-device-removed"><primary sortas="libhal_ctx_set_device_removed">libhal_ctx_set_device_removed</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_device_removed       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceRemoved">LibHalDeviceRemoved</link> callback);</programlisting>
<para>
Set the callback for when a device is removed.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device is removed
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-device-new-capability" role="function">
<title>libhal_ctx_set_device_new_capability ()</title>
<indexterm zone="libhal-ctx-set-device-new-capability"><primary sortas="libhal_ctx_set_device_new_capability">libhal_ctx_set_device_new_capability</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_device_new_capability
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceNewCapability">LibHalDeviceNewCapability</link> callback);</programlisting>
<para>
Set the callback for when a device gains a new capability.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device gains a new capability
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-device-lost-capability" role="function">
<title>libhal_ctx_set_device_lost_capability ()</title>
<indexterm zone="libhal-ctx-set-device-lost-capability"><primary sortas="libhal_ctx_set_device_lost_capability">libhal_ctx_set_device_lost_capability</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_device_lost_capability
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceLostCapability">LibHalDeviceLostCapability</link> callback);</programlisting>
<para>
Set the callback for when a device loses a capability</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device loses a capability
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-device-property-modified" role="function">
<title>libhal_ctx_set_device_property_modified ()</title>
<indexterm zone="libhal-ctx-set-device-property-modified"><primary sortas="libhal_ctx_set_device_property_modified">libhal_ctx_set_device_property_modified</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_device_property_modified
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDevicePropertyModified">LibHalDevicePropertyModified</link> callback);</programlisting>
<para>
Set the callback for when a property is modified on a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a property is modified on a device
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-device-condition" role="function">
<title>libhal_ctx_set_device_condition ()</title>
<indexterm zone="libhal-ctx-set-device-condition"><primary sortas="libhal_ctx_set_device_condition">libhal_ctx_set_device_condition</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_device_condition     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalDeviceCondition">LibHalDeviceCondition</link> callback);</programlisting>
<para>
Set the callback for when a device emits a condition</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device emits a condition
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-global-interface-lock-acquired" role="function">
<title>libhal_ctx_set_global_interface_lock_acquired ()</title>
<indexterm zone="libhal-ctx-set-global-interface-lock-acquired"><primary sortas="libhal_ctx_set_global_interface_lock_acquired">libhal_ctx_set_global_interface_lock_acquired</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_global_interface_lock_acquired
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalGlobalInterfaceLockAcquired">LibHalGlobalInterfaceLockAcquired</link> callback);</programlisting>
<para>
Set the callback for when a global interface lock is acquired.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the callback
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-global-interface-lock-released" role="function">
<title>libhal_ctx_set_global_interface_lock_released ()</title>
<indexterm zone="libhal-ctx-set-global-interface-lock-released"><primary sortas="libhal_ctx_set_global_interface_lock_released">libhal_ctx_set_global_interface_lock_released</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_global_interface_lock_released
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalGlobalInterfaceLockReleased">LibHalGlobalInterfaceLockReleased</link> callback);</programlisting>
<para>
Set the callback for when a global interface lock is released.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the callback
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-interface-lock-acquired" role="function">
<title>libhal_ctx_set_interface_lock_acquired ()</title>
<indexterm zone="libhal-ctx-set-interface-lock-acquired"><primary sortas="libhal_ctx_set_interface_lock_acquired">libhal_ctx_set_interface_lock_acquired</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_interface_lock_acquired
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalInterfaceLockAcquired">LibHalInterfaceLockAcquired</link> callback);</programlisting>
<para>
Set the callback for when an interface lock is acquired.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the callback
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-interface-lock-released" role="function">
<title>libhal_ctx_set_interface_lock_released ()</title>
<indexterm zone="libhal-ctx-set-interface-lock-released"><primary sortas="libhal_ctx_set_interface_lock_released">libhal_ctx_set_interface_lock_released</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_interface_lock_released
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalInterfaceLockReleased">LibHalInterfaceLockReleased</link> callback);</programlisting>
<para>
Set the callback for when an interface lock is released.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the callback
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-singleton-device-added" role="function">
<title>libhal_ctx_set_singleton_device_added ()</title>
<indexterm zone="libhal-ctx-set-singleton-device-added"><primary sortas="libhal_ctx_set_singleton_device_added">libhal_ctx_set_singleton_device_added</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_singleton_device_added
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalSingletonDeviceAdded">LibHalSingletonDeviceAdded</link> callback);</programlisting>
<para>
Set the callback for when a singleton should handle a new device</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device emits a condition
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-set-singleton-device-removed" role="function">
<title>libhal_ctx_set_singleton_device_removed ()</title>
<indexterm zone="libhal-ctx-set-singleton-device-removed"><primary sortas="libhal_ctx_set_singleton_device_removed">libhal_ctx_set_singleton_device_removed</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_set_singleton_device_removed
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalSingletonDeviceRemoved">LibHalSingletonDeviceRemoved</link> callback);</programlisting>
<para>
Set the callback for when a singleton should discard a device</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>callback</parameter>&#160;:</term>
<listitem><simpara> the function to call when a device emits a condition
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if callback was successfully set, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-init" role="function">
<title>libhal_ctx_init ()</title>
<indexterm zone="libhal-ctx-init"><primary sortas="libhal_ctx_init">libhal_ctx_init</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_init                     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Initialize the connection to hald.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> Context for connection to hald (D-BUS connection should be set with libhal_ctx_set_dbus_connection)
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if initialization succeeds, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-shutdown" role="function">
<title>libhal_ctx_shutdown ()</title>
<indexterm zone="libhal-ctx-shutdown"><primary sortas="libhal_ctx_shutdown">libhal_ctx_shutdown</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_shutdown                 (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Shut down a connection to hald.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if connection successfully shut down, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-free" role="function">
<title>libhal_ctx_free ()</title>
<indexterm zone="libhal-ctx-free"><primary sortas="libhal_ctx_free">libhal_ctx_free</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ctx_free                     (<link linkend="LibHalContext">LibHalContext</link> *ctx);</programlisting>
<para>
Free a LibHalContext resource.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> pointer to a LibHalContext
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ctx-init-direct" role="function">
<title>libhal_ctx_init_direct ()</title>
<indexterm zone="libhal-ctx-init-direct"><primary sortas="libhal_ctx_init_direct">libhal_ctx_init_direct</primary></indexterm><programlisting><link linkend="LibHalContext">LibHalContext</link> *     libhal_ctx_init_direct              (<link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Create an already initialized connection to hald. This function should only be used by HAL helpers.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> A pointer to an already initialized LibHalContext
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-get-all-devices" role="function">
<title>libhal_get_all_devices ()</title>
<indexterm zone="libhal-get-all-devices"><primary sortas="libhal_get_all_devices">libhal_get_all_devices</primary></indexterm><programlisting><link linkend="char">char</link> **             libhal_get_all_devices              (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="int">int</link> *num_devices,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get all devices in the Global Device List (GDL).</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_devices</parameter>&#160;:</term>
<listitem><simpara> the number of devices will be stored here
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> An array of device identifiers terminated with NULL. It is
the responsibility of the caller to free with
<link linkend="libhal-free-string-array"><function>libhal_free_string_array()</function></link>. If an error occurs NULL is returned.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-exists" role="function">
<title>libhal_device_exists ()</title>
<indexterm zone="libhal-device-exists"><primary sortas="libhal_device_exists">libhal_device_exists</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_exists                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Determine if a device exists.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique device id.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the device exists
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-print" role="function">
<title>libhal_device_print ()</title>
<indexterm zone="libhal-device-print"><primary sortas="libhal_device_print">libhal_device_print</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_print                 (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Print a device to stdout; useful for debugging.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if device's information could be obtained, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-exists" role="function">
<title>libhal_device_property_exists ()</title>
<indexterm zone="libhal-device-property-exists"><primary sortas="libhal_device_property_exists">libhal_device_property_exists</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_exists       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Determine if a property on a device exists.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique device id.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the device exists, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-string" role="function">
<title>libhal_device_get_property_string ()</title>
<indexterm zone="libhal-device-get-property-string"><primary sortas="libhal_device_get_property_string">libhal_device_get_property_string</primary></indexterm><programlisting><link linkend="char">char</link> *              libhal_device_get_property_string   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get the value of a property of type string.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> the name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> UTF8 nul-terminated string. The caller is responsible for
freeing this string with the function <link linkend="libhal-free-string"><function>libhal_free_string()</function></link>. Returns
NULL if the property didn't exist or we are OOM.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-int" role="function">
<title>libhal_device_get_property_int ()</title>
<indexterm zone="libhal-device-get-property-int"><primary sortas="libhal_device_get_property_int">libhal_device_get_property_int</primary></indexterm><programlisting><link linkend="dbus-int32-t">dbus_int32_t</link>        libhal_device_get_property_int      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get the value of a property of type integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Property value (32-bit signed integer)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-uint64" role="function">
<title>libhal_device_get_property_uint64 ()</title>
<indexterm zone="libhal-device-get-property-uint64"><primary sortas="libhal_device_get_property_uint64">libhal_device_get_property_uint64</primary></indexterm><programlisting><link linkend="dbus-uint64-t">dbus_uint64_t</link>       libhal_device_get_property_uint64   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get the value of a property of type signed integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Property value (64-bit unsigned integer)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-double" role="function">
<title>libhal_device_get_property_double ()</title>
<indexterm zone="libhal-device-get-property-double"><primary sortas="libhal_device_get_property_double">libhal_device_get_property_double</primary></indexterm><programlisting><link linkend="double">double</link>              libhal_device_get_property_double   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get the value of a property of type double.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Property value (IEEE754 double precision float)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-bool" role="function">
<title>libhal_device_get_property_bool ()</title>
<indexterm zone="libhal-device-get-property-bool"><primary sortas="libhal_device_get_property_bool">libhal_device_get_property_bool</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_get_property_bool     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get the value of a property of type bool.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Property value (boolean)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-strlist" role="function">
<title>libhal_device_get_property_strlist ()</title>
<indexterm zone="libhal-device-get-property-strlist"><primary sortas="libhal_device_get_property_strlist">libhal_device_get_property_strlist</primary></indexterm><programlisting><link linkend="char">char</link> **             libhal_device_get_property_strlist  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get the value of a property of type string list.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Array of pointers to UTF8 nul-terminated strings
terminated by NULL. The caller is responsible for freeing this
string array with the function <link linkend="libhal-free-string-array"><function>libhal_free_string_array()</function></link>. Returns
NULL if the property didn't exist or we are OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-set-property-string" role="function">
<title>libhal_device_set_property_string ()</title>
<indexterm zone="libhal-device-set-property-string"><primary sortas="libhal_device_set_property_string">libhal_device_set_property_string</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_set_property_string   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Set a property of type string.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value of the property; a UTF8 string
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the property was set, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-set-property-int" role="function">
<title>libhal_device_set_property_int ()</title>
<indexterm zone="libhal-device-set-property-int"><primary sortas="libhal_device_set_property_int">libhal_device_set_property_int</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_set_property_int      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-int32-t">dbus_int32_t</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Set a property of type signed integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the property was set, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-set-property-uint64" role="function">
<title>libhal_device_set_property_uint64 ()</title>
<indexterm zone="libhal-device-set-property-uint64"><primary sortas="libhal_device_set_property_uint64">libhal_device_set_property_uint64</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_set_property_uint64   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-uint64-t">dbus_uint64_t</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Set a property of type unsigned integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the property was set, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-set-property-double" role="function">
<title>libhal_device_set_property_double ()</title>
<indexterm zone="libhal-device-set-property-double"><primary sortas="libhal_device_set_property_double">libhal_device_set_property_double</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_set_property_double   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="double">double</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Set a property of type double.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the property was set, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-set-property-bool" role="function">
<title>libhal_device_set_property_bool ()</title>
<indexterm zone="libhal-device-set-property-bool"><primary sortas="libhal_device_set_property_bool">libhal_device_set_property_bool</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_set_property_bool     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Set a property of type bool.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the property was set, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-strlist-append" role="function">
<title>libhal_device_property_strlist_append ()</title>
<indexterm zone="libhal-device-property-strlist-append"><primary sortas="libhal_device_property_strlist_append">libhal_device_property_strlist_append</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_strlist_append
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Append to a property of type strlist.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value to append to property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the value was appended, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-strlist-prepend" role="function">
<title>libhal_device_property_strlist_prepend ()</title>
<indexterm zone="libhal-device-property-strlist-prepend"><primary sortas="libhal_device_property_strlist_prepend">libhal_device_property_strlist_prepend</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_strlist_prepend
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Prepend to a property of type strlist.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> value to prepend to property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the value was prepended, FALSE if the device
didn't exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-strlist-remove-index" role="function">
<title>libhal_device_property_strlist_remove_index ()</title>
<indexterm zone="libhal-device-property-strlist-remove-index"><primary sortas="libhal_device_property_strlist_remove_index">libhal_device_property_strlist_remove_index</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_strlist_remove_index
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         unsigned <link linkend="int">int</link> idx,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Remove a specified string from a property of type strlist.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>idx</parameter>&#160;:</term>
<listitem><simpara> index of string to remove in the strlist
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the string was removed, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-strlist-remove" role="function">
<title>libhal_device_property_strlist_remove ()</title>
<indexterm zone="libhal-device-property-strlist-remove"><primary sortas="libhal_device_property_strlist_remove">libhal_device_property_strlist_remove</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_strlist_remove
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Remove a specified string from a property of type strlist.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the string to remove
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the string was removed, FALSE if the device didn't
exist or the property had a different type.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-remove-property" role="function">
<title>libhal_device_remove_property ()</title>
<indexterm zone="libhal-device-remove-property"><primary sortas="libhal_device_remove_property">libhal_device_remove_property</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_remove_property       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Remove a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the property was set, FALSE if the device didn't
exist
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-property-type" role="function">
<title>libhal_device_get_property_type ()</title>
<indexterm zone="libhal-device-get-property-type"><primary sortas="libhal_device_get_property_type">libhal_device_get_property_type</primary></indexterm><programlisting><link linkend="LibHalPropertyType">LibHalPropertyType</link>  libhal_device_get_property_type     (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Query a property type of a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> A LibHalPropertyType. LIBHAL_PROPERTY_TYPE_INVALID is
return if the property doesn't exist.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalChangeSet-s" role="struct">
<title>struct LibHalChangeSet_s</title>
<indexterm zone="LibHalChangeSet-s"><primary sortas="LibHalChangeSet_s">LibHalChangeSet_s</primary></indexterm><programlisting>struct LibHalChangeSet_s;</programlisting>
<para>
</para></refsect2>
<refsect2 id="LibHalChangeSet" role="typedef">
<title>LibHalChangeSet</title>
<indexterm zone="LibHalChangeSet"><primary sortas="LibHalChangeSet">LibHalChangeSet</primary></indexterm><programlisting>typedef struct LibHalChangeSet_s LibHalChangeSet;
</programlisting>
<para>
</para></refsect2>
<refsect2 id="libhal-device-new-changeset" role="function">
<title>libhal_device_new_changeset ()</title>
<indexterm zone="libhal-device-new-changeset"><primary sortas="libhal_device_new_changeset">libhal_device_new_changeset</primary></indexterm><programlisting><link linkend="LibHalChangeSet">LibHalChangeSet</link> *   libhal_device_new_changeset         (const <link linkend="char">char</link> *udi);</programlisting>
<para>
Request a new changeset object. Used for changing multiple properties at once. Useful when
performance is critical and also for atomically updating several properties.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> unique device identifier
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> A new changeset object or NULL on error
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-changeset-set-property-string" role="function">
<title>libhal_changeset_set_property_string ()</title>
<indexterm zone="libhal-changeset-set-property-string"><primary sortas="libhal_changeset_set_property_string">libhal_changeset_set_property_string</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_changeset_set_property_string
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value);</programlisting>
<para>
Set a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> key of property 
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to set
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE on OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-changeset-set-property-int" role="function">
<title>libhal_changeset_set_property_int ()</title>
<indexterm zone="libhal-changeset-set-property-int"><primary sortas="libhal_changeset_set_property_int">libhal_changeset_set_property_int</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_changeset_set_property_int   (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-int32-t">dbus_int32_t</link> value);</programlisting>
<para>
Set a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> key of property 
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to set
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE on OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-changeset-set-property-uint64" role="function">
<title>libhal_changeset_set_property_uint64 ()</title>
<indexterm zone="libhal-changeset-set-property-uint64"><primary sortas="libhal_changeset_set_property_uint64">libhal_changeset_set_property_uint64</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_changeset_set_property_uint64
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-uint64-t">dbus_uint64_t</link> value);</programlisting>
<para>
Set a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> key of property 
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to set
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE on OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-changeset-set-property-double" role="function">
<title>libhal_changeset_set_property_double ()</title>
<indexterm zone="libhal-changeset-set-property-double"><primary sortas="libhal_changeset_set_property_double">libhal_changeset_set_property_double</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_changeset_set_property_double
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="double">double</link> value);</programlisting>
<para>
Set a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> key of property 
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to set
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE on OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-changeset-set-property-bool" role="function">
<title>libhal_changeset_set_property_bool ()</title>
<indexterm zone="libhal-changeset-set-property-bool"><primary sortas="libhal_changeset_set_property_bool">libhal_changeset_set_property_bool</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_changeset_set_property_bool  (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> value);</programlisting>
<para>
Set a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> key of property 
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to set
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE on OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-changeset-set-property-strlist" role="function">
<title>libhal_changeset_set_property_strlist ()</title>
<indexterm zone="libhal-changeset-set-property-strlist"><primary sortas="libhal_changeset_set_property_strlist">libhal_changeset_set_property_strlist</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_changeset_set_property_strlist
                                                        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> **value);</programlisting>
<para>
Set a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> key of property 
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to set - NULL terminated array of strings
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE on OOM
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-commit-changeset" role="function">
<title>libhal_device_commit_changeset ()</title>
<indexterm zone="libhal-device-commit-changeset"><primary sortas="libhal_device_commit_changeset">libhal_device_commit_changeset</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_commit_changeset      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Commit a changeset to the daemon.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset to commit
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> True if the changeset was committed on the daemon side
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-free-changeset" role="function">
<title>libhal_device_free_changeset ()</title>
<indexterm zone="libhal-device-free-changeset"><primary sortas="libhal_device_free_changeset">libhal_device_free_changeset</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_device_free_changeset        (<link linkend="LibHalChangeSet">LibHalChangeSet</link> *changeset);</programlisting>
<para>
Free a changeset.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>changeset</parameter>&#160;:</term>
<listitem><simpara> the changeset to free
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-get-all-properties" role="function">
<title>libhal_device_get_all_properties ()</title>
<indexterm zone="libhal-device-get-all-properties"><primary sortas="libhal_device_get_all_properties">libhal_device_get_all_properties</primary></indexterm><programlisting><link linkend="LibHalPropertySet">LibHalPropertySet</link> * libhal_device_get_all_properties    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Retrieve all the properties on a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> An object represent all properties. Must be freed with <link linkend="libhal-free-property-set"><function>libhal_free_property_set()</function></link>.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-get-all-devices-with-properties" role="function">
<title>libhal_get_all_devices_with_properties ()</title>
<indexterm zone="libhal-get-all-devices-with-properties"><primary sortas="libhal_get_all_devices_with_properties">libhal_get_all_devices_with_properties</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_get_all_devices_with_properties
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="int">int</link> *out_num_devices,
                                                         <link linkend="char">char</link> ***out_udi,
                                                         <link linkend="LibHalPropertySet">LibHalPropertySet</link> ***out_properties,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Get all devices in the hal database as well as all properties for each device.
</para>
<para>
Return: <link linkend="TRUE--CAPS"><literal>TRUE</literal></link> if success; <link linkend="FALSE--CAPS"><literal>FALSE</literal></link> and <parameter>error</parameter> will be set.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>out_num_devices</parameter>&#160;:</term>
<listitem><simpara> Return location for number of devices
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>out_udi</parameter>&#160;:</term>
<listitem><simpara> Return location for array of of udi's. Caller should free this with <link linkend="libhal-free-string-array"><function>libhal_free_string_array()</function></link> when done with it.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>out_properties</parameter>&#160;:</term>
<listitem><simpara> Return location for array of <link linkend="LibHalPropertySet"><type>LibHalPropertySet</type></link> objects. Caller should free each one of them with <link linkend="libhal-free-property-set"><function>libhal_free_property_set()</function></link> when done with it
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> Return location for error
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-property-set-sort" role="function">
<title>libhal_property_set_sort ()</title>
<indexterm zone="libhal-property-set-sort"><primary sortas="libhal_property_set_sort">libhal_property_set_sort</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_property_set_sort            (<link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);</programlisting>
<para>
Sort all properties according to property name.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property-set to sort
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-free-property-set" role="function">
<title>libhal_free_property_set ()</title>
<indexterm zone="libhal-free-property-set"><primary sortas="libhal_free_property_set">libhal_free_property_set</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_free_property_set            (<link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);</programlisting>
<para>
Free a property set earlier obtained with <link linkend="libhal-device-get-all-properties"><function>libhal_device_get_all_properties()</function></link>.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property-set to free
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-property-set-get-num-elems" role="function">
<title>libhal_property_set_get_num_elems ()</title>
<indexterm zone="libhal-property-set-get-num-elems"><primary sortas="libhal_property_set_get_num_elems">libhal_property_set_get_num_elems</primary></indexterm><programlisting>unsigned <link linkend="int">int</link>        libhal_property_set_get_num_elems   (<link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);</programlisting>
<para>
Get the number of properties in a property set.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set to consider
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> number of properties in given property set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ps-get-type" role="function">
<title>libhal_ps_get_type ()</title>
<indexterm zone="libhal-ps-get-type"><primary sortas="libhal_ps_get_type">libhal_ps_get_type</primary></indexterm><programlisting><link linkend="LibHalPropertyType">LibHalPropertyType</link>  libhal_ps_get_type                  (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);</programlisting>
<para>
Get the type of a given property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of property to inspect
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> the <link linkend="LibHalPropertyType"><type>LibHalPropertyType</type></link> of the given property, 
LIBHAL_PROPERTY_TYPE_INVALID if property is not in the set
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ps-get-string" role="function">
<title>libhal_ps_get_string ()</title>
<indexterm zone="libhal-ps-get-string"><primary sortas="libhal_ps_get_string">libhal_ps_get_string</primary></indexterm><programlisting>const <link linkend="char">char</link> *        libhal_ps_get_string                (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);</programlisting>
<para>
Get the value of a property of type string.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of property to inspect
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> UTF8 nul-terminated string. This pointer is only valid
until <link linkend="libhal-free-property-set"><function>libhal_free_property_set()</function></link> is invoked on the property set
this property belongs to. NULL if property is not in the set or not a string
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ps-get-int32" role="function">
<title>libhal_ps_get_int32 ()</title>
<indexterm zone="libhal-ps-get-int32"><primary sortas="libhal_ps_get_int32">libhal_ps_get_int32</primary></indexterm><programlisting><link linkend="dbus-int32-t">dbus_int32_t</link>        libhal_ps_get_int32                 (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);</programlisting>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ps-get-uint64" role="function">
<title>libhal_ps_get_uint64 ()</title>
<indexterm zone="libhal-ps-get-uint64"><primary sortas="libhal_ps_get_uint64">libhal_ps_get_uint64</primary></indexterm><programlisting><link linkend="dbus-uint64-t">dbus_uint64_t</link>       libhal_ps_get_uint64                (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);</programlisting>
<para>
Get the value of a property of type unsigned integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of property to inspect
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (64-bit unsigned integer)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ps-get-double" role="function">
<title>libhal_ps_get_double ()</title>
<indexterm zone="libhal-ps-get-double"><primary sortas="libhal_ps_get_double">libhal_ps_get_double</primary></indexterm><programlisting><link linkend="double">double</link>              libhal_ps_get_double                (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);</programlisting>
<para>
Get the value of a property of type double.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of property to inspect
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (IEEE754 double precision float)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-ps-get-bool" role="function">
<title>libhal_ps_get_bool ()</title>
<indexterm zone="libhal-ps-get-bool"><primary sortas="libhal_ps_get_bool">libhal_ps_get_bool</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_ps_get_bool                  (const <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set,
                                                         const <link linkend="char">char</link> *key);</programlisting>
<para>
Get the value of a property of type bool.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of property to inspect
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (bool)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="LibHalPropertySetIterator" role="typedef">
<title>LibHalPropertySetIterator</title>
<indexterm zone="LibHalPropertySetIterator"><primary sortas="LibHalPropertySetIterator">LibHalPropertySetIterator</primary></indexterm><programlisting>typedef struct LibHalPropertySetIterator_s LibHalPropertySetIterator;
</programlisting>
<para>
Iterator for inspecting all properties. Do not access any members;
use the libhal_psi_* family of functions instead.</para>
<para>
</para></refsect2>
<refsect2 id="libhal-psi-init" role="function">
<title>libhal_psi_init ()</title>
<indexterm zone="libhal-psi-init"><primary sortas="libhal_psi_init">libhal_psi_init</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_psi_init                     (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter,
                                                         <link linkend="LibHalPropertySet">LibHalPropertySet</link> *set);</programlisting>
<para>
Initialize a property set iterator.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>set</parameter>&#160;:</term>
<listitem><simpara> property set to iterate over
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-has-more" role="function">
<title>libhal_psi_has_more ()</title>
<indexterm zone="libhal-psi-has-more"><primary sortas="libhal_psi_has_more">libhal_psi_has_more</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_psi_has_more                 (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Determine whether there are more properties to iterate over.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if there are more properties, FALSE otherwise.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-next" role="function">
<title>libhal_psi_next ()</title>
<indexterm zone="libhal-psi-next"><primary sortas="libhal_psi_next">libhal_psi_next</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_psi_next                     (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Advance iterator to next property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-type" role="function">
<title>libhal_psi_get_type ()</title>
<indexterm zone="libhal-psi-get-type"><primary sortas="libhal_psi_get_type">libhal_psi_get_type</primary></indexterm><programlisting><link linkend="LibHalPropertyType">LibHalPropertyType</link>  libhal_psi_get_type                 (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get type of property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> the property type at the iterator's position
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-key" role="function">
<title>libhal_psi_get_key ()</title>
<indexterm zone="libhal-psi-get-key"><primary sortas="libhal_psi_get_key">libhal_psi_get_key</primary></indexterm><programlisting><link linkend="char">char</link> *              libhal_psi_get_key                  (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the key of a property.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> ASCII nul-terminated string. This pointer is only valid
until <link linkend="libhal-free-property-set"><function>libhal_free_property_set()</function></link> is invoked on the property set
this property belongs to.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-string" role="function">
<title>libhal_psi_get_string ()</title>
<indexterm zone="libhal-psi-get-string"><primary sortas="libhal_psi_get_string">libhal_psi_get_string</primary></indexterm><programlisting><link linkend="char">char</link> *              libhal_psi_get_string               (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the value of a property of type string.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> UTF8 nul-terminated string. This pointer is only valid
until <link linkend="libhal-free-property-set"><function>libhal_free_property_set()</function></link> is invoked on the property set
this property belongs to.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-int" role="function">
<title>libhal_psi_get_int ()</title>
<indexterm zone="libhal-psi-get-int"><primary sortas="libhal_psi_get_int">libhal_psi_get_int</primary></indexterm><programlisting><link linkend="dbus-int32-t">dbus_int32_t</link>        libhal_psi_get_int                  (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the value of a property of type signed integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (32-bit signed integer)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-uint64" role="function">
<title>libhal_psi_get_uint64 ()</title>
<indexterm zone="libhal-psi-get-uint64"><primary sortas="libhal_psi_get_uint64">libhal_psi_get_uint64</primary></indexterm><programlisting><link linkend="dbus-uint64-t">dbus_uint64_t</link>       libhal_psi_get_uint64               (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the value of a property of type unsigned integer.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (64-bit unsigned integer)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-double" role="function">
<title>libhal_psi_get_double ()</title>
<indexterm zone="libhal-psi-get-double"><primary sortas="libhal_psi_get_double">libhal_psi_get_double</primary></indexterm><programlisting><link linkend="double">double</link>              libhal_psi_get_double               (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the value of a property of type double.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (IEEE754 double precision float)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-bool" role="function">
<title>libhal_psi_get_bool ()</title>
<indexterm zone="libhal-psi-get-bool"><primary sortas="libhal_psi_get_bool">libhal_psi_get_bool</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_psi_get_bool                 (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the value of a property of type bool.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> property value (bool)
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-psi-get-strlist" role="function">
<title>libhal_psi_get_strlist ()</title>
<indexterm zone="libhal-psi-get-strlist"><primary sortas="libhal_psi_get_strlist">libhal_psi_get_strlist</primary></indexterm><programlisting><link linkend="char">char</link> **             libhal_psi_get_strlist              (<link linkend="LibHalPropertySetIterator">LibHalPropertySetIterator</link> *iter);</programlisting>
<para>
Get the value of a property of type string list.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>iter</parameter>&#160;:</term>
<listitem><simpara> iterator object
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> pointer to array of strings
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-string-array-length" role="function">
<title>libhal_string_array_length ()</title>
<indexterm zone="libhal-string-array-length"><primary sortas="libhal_string_array_length">libhal_string_array_length</primary></indexterm><programlisting>unsigned <link linkend="int">int</link>        libhal_string_array_length          (<link linkend="char">char</link> **str_array);</programlisting>
<para>
Get the length of an array of strings.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>str_array</parameter>&#160;:</term>
<listitem><simpara> array of strings to consider
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Number of strings in array
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-free-string-array" role="function">
<title>libhal_free_string_array ()</title>
<indexterm zone="libhal-free-string-array"><primary sortas="libhal_free_string_array">libhal_free_string_array</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_free_string_array            (<link linkend="char">char</link> **str_array);</programlisting>
<para>
Frees a NULL-terminated array of strings. If passed NULL, does nothing.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>str_array</parameter>&#160;:</term>
<listitem><simpara> the array to be freed
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-free-string" role="function">
<title>libhal_free_string ()</title>
<indexterm zone="libhal-free-string"><primary sortas="libhal_free_string">libhal_free_string</primary></indexterm><programlisting><link linkend="void">void</link>                libhal_free_string                  (<link linkend="char">char</link> *str);</programlisting>
<para>
Used to free strings returned by libhal.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>str</parameter>&#160;:</term>
<listitem><simpara> the nul-terminated sting to free
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-new-device" role="function">
<title>libhal_new_device ()</title>
<indexterm zone="libhal-new-device"><primary sortas="libhal_new_device">libhal_new_device</primary></indexterm><programlisting><link linkend="char">char</link> *              libhal_new_device                   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Create a new device object which will be hidden from applications
until the <link linkend="CommitToGdl"><function>CommitToGdl()</function></link>, ie. <link linkend="libhal-device-commit-to-gdl"><function>libhal_device_commit_to_gdl()</function></link>, method
is called. Note that the program invoking this method needs to run
with super user privileges.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Temporary device unique id or NULL if there was a
problem. This string must be freed by the caller.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-commit-to-gdl" role="function">
<title>libhal_device_commit_to_gdl ()</title>
<indexterm zone="libhal-device-commit-to-gdl"><primary sortas="libhal_device_commit_to_gdl">libhal_device_commit_to_gdl</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_commit_to_gdl         (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *temp_udi,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
When a hidden device has been built using the NewDevice method,
ie. <link linkend="libhal-new-device"><function>libhal_new_device()</function></link>, and the org.freedesktop.Hal.Device
interface this function will commit it to the global device list.
</para>
<para>
This means that the device object will be visible to applications
and the HAL daemon will possibly attempt to boot the device
(depending on the property RequireEnable).
</para>
<para>
Note that the program invoking this method needs to run with super
user privileges.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>temp_udi</parameter>&#160;:</term>
<listitem><simpara> the temporary unique device id as returned by <link linkend="libhal-new-device"><function>libhal_new_device()</function></link>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the new unique device id.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> FALSE if the given unique device id is already in use.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-remove-device" role="function">
<title>libhal_remove_device ()</title>
<indexterm zone="libhal-remove-device"><primary sortas="libhal_remove_device">libhal_remove_device</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_remove_device                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
This method can be invoked when a device is removed. The HAL daemon
will shut down the device. Note that the device may still be in the
device list if the Persistent property is set to true.
</para>
<para>
Note that the program invoking this method needs to run with super
user privileges.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique device id.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the device was removed, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-merge-properties" role="function">
<title>libhal_merge_properties ()</title>
<indexterm zone="libhal-merge-properties"><primary sortas="libhal_merge_properties">libhal_merge_properties</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_merge_properties             (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *target_udi,
                                                         const <link linkend="char">char</link> *source_udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Merge properties from one device to another.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>target_udi</parameter>&#160;:</term>
<listitem><simpara> the Unique device id of target device to merge to
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>source_udi</parameter>&#160;:</term>
<listitem><simpara> the Unique device id of device to merge from
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the properties were merged, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-matches" role="function">
<title>libhal_device_matches ()</title>
<indexterm zone="libhal-device-matches"><primary sortas="libhal_device_matches">libhal_device_matches</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_matches               (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi1,
                                                         const <link linkend="char">char</link> *udi2,
                                                         const <link linkend="char">char</link> *property_namespace,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Check a set of properties for two devices matches. 
</para>
<para>
Checks that all properties where keys, starting with a given value
(namespace), of the first device is in the second device and that
they got the same value and type.
</para>
<para>
Note that the other inclusion isn't tested, so there could be
properties (from the given namespace) in the second device not
present in the first device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi1</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id for device 1
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi2</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id for device 2
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>property_namespace</parameter>&#160;:</term>
<listitem><simpara> the namespace for set of devices, e.g. "usb"
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if all properties starting with the given namespace
parameter from one device is in the other and have the same value.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-manager-find-device-string-match" role="function">
<title>libhal_manager_find_device_string_match ()</title>
<indexterm zone="libhal-manager-find-device-string-match"><primary sortas="libhal_manager_find_device_string_match">libhal_manager_find_device_string_match</primary></indexterm><programlisting><link linkend="char">char</link> **             libhal_manager_find_device_string_match
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *key,
                                                         const <link linkend="char">char</link> *value,
                                                         <link linkend="int">int</link> *num_devices,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Find a device in the GDL where a single string property matches a
given value.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>key</parameter>&#160;:</term>
<listitem><simpara> name of the property
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>value</parameter>&#160;:</term>
<listitem><simpara> the value to match
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_devices</parameter>&#160;:</term>
<listitem><simpara> pointer to store number of devices
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> UDI of devices; free with <link linkend="libhal-free-string-array"><function>libhal_free_string_array()</function></link>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-add-capability" role="function">
<title>libhal_device_add_capability ()</title>
<indexterm zone="libhal-device-add-capability"><primary sortas="libhal_device_add_capability">libhal_device_add_capability</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_add_capability        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Assign a capability to a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>capability</parameter>&#160;:</term>
<listitem><simpara> the capability name to add
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the capability was added, FALSE if the device didn't exist
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-query-capability" role="function">
<title>libhal_device_query_capability ()</title>
<indexterm zone="libhal-device-query-capability"><primary sortas="libhal_device_query_capability">libhal_device_query_capability</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_query_capability      (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *capability,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Check if a device has a capability. The result is undefined if the
device doesn't exist.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>capability</parameter>&#160;:</term>
<listitem><simpara> the capability name
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the device has the capability, otherwise FALSE
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-find-device-by-capability" role="function">
<title>libhal_find_device_by_capability ()</title>
<indexterm zone="libhal-find-device-by-capability"><primary sortas="libhal_find_device_by_capability">libhal_find_device_by_capability</primary></indexterm><programlisting><link linkend="char">char</link> **             libhal_find_device_by_capability    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *capability,
                                                         <link linkend="int">int</link> *num_devices,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Find devices with a given capability.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>capability</parameter>&#160;:</term>
<listitem><simpara> the capability name
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>num_devices</parameter>&#160;:</term>
<listitem><simpara> pointer to store number of devices
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> UDI of devices; free with <link linkend="libhal-free-string-array"><function>libhal_free_string_array()</function></link>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-watch-all" role="function">
<title>libhal_device_property_watch_all ()</title>
<indexterm zone="libhal-device-property-watch-all"><primary sortas="libhal_device_property_watch_all">libhal_device_property_watch_all</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_watch_all    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Watch all devices, ie. the device_property_changed callback is
invoked when the properties on any device changes.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE only if the operation succeeded
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-property-remove-watch-all" role="function">
<title>libhal_device_property_remove_watch_all ()</title>
<indexterm zone="libhal-device-property-remove-watch-all"><primary sortas="libhal_device_property_remove_watch_all">libhal_device_property_remove_watch_all</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_property_remove_watch_all
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara>
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara>
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara>
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-add-property-watch" role="function">
<title>libhal_device_add_property_watch ()</title>
<indexterm zone="libhal-device-add-property-watch"><primary sortas="libhal_device_add_property_watch">libhal_device_add_property_watch</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_add_property_watch    (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Add a watch on a device, so the device_property_changed callback is
invoked when the properties on the given device changes.
</para>
<para>
The application itself is responsible for deleting the watch, using
libhal_device_remove_property_watch, if the device is removed.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE only if the operation succeeded
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-remove-property-watch" role="function">
<title>libhal_device_remove_property_watch ()</title>
<indexterm zone="libhal-device-remove-property-watch"><primary sortas="libhal_device_remove_property_watch">libhal_device_remove_property_watch</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_remove_property_watch (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Remove a watch on a device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE only if the operation succeeded
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-lock" role="function">
<title>libhal_device_lock ()</title>
<indexterm zone="libhal-device-lock"><primary sortas="libhal_device_lock">libhal_device_lock</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_lock                  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *reason_to_lock,
                                                         <link linkend="char">char</link> **reason_why_locked,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Take an advisory lock on the device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>reason_to_lock</parameter>&#160;:</term>
<listitem><simpara> a user-presentable reason why the device is locked.
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>reason_why_locked</parameter>&#160;:</term>
<listitem><simpara> a pointer to store the reason why the device cannot be locked on failure, or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the lock was obtained, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-unlock" role="function">
<title>libhal_device_unlock ()</title>
<indexterm zone="libhal-device-unlock"><primary sortas="libhal_device_unlock">libhal_device_unlock</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_unlock                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Release an advisory lock on the device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the device was successfully unlocked,
                             FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-rescan" role="function">
<title>libhal_device_rescan ()</title>
<indexterm zone="libhal-device-rescan"><primary sortas="libhal_device_rescan">libhal_device_rescan</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_rescan                (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
TODO document me.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Whether the operation succeeded
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-reprobe" role="function">
<title>libhal_device_reprobe ()</title>
<indexterm zone="libhal-device-reprobe"><primary sortas="libhal_device_reprobe">libhal_device_reprobe</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_reprobe               (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
TODO document me.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Whether the operation succeeded
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-emit-condition" role="function">
<title>libhal_device_emit_condition ()</title>
<indexterm zone="libhal-device-emit-condition"><primary sortas="libhal_device_emit_condition">libhal_device_emit_condition</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_emit_condition        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *condition_name,
                                                         const <link linkend="char">char</link> *condition_details,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Emit a condition from a device. Can only be used from hald helpers.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>condition_name</parameter>&#160;:</term>
<listitem><simpara> user-readable name of condition
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>condition_details</parameter>&#160;:</term>
<listitem><simpara> user-readable details of condition
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if condition successfully emitted,
                             FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-claim-interface" role="function">
<title>libhal_device_claim_interface ()</title>
<indexterm zone="libhal-device-claim-interface"><primary sortas="libhal_device_claim_interface">libhal_device_claim_interface</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_claim_interface       (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface_name,
                                                         const <link linkend="char">char</link> *introspection_xml,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Claim an interface for a device. All messages to this interface
will be forwarded to the helper. Can only be used from hald
helpers.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface_name</parameter>&#160;:</term>
<listitem><simpara> Name of interface to claim, e.g. org.freedesktop.Hal.Device.FoobarKindOfThing
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>introspection_xml</parameter>&#160;:</term>
<listitem><simpara> Introspection XML containing what would be inside the interface XML tag
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if interface was claimed, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-addon-is-ready" role="function">
<title>libhal_device_addon_is_ready ()</title>
<indexterm zone="libhal-device-addon-is-ready"><primary sortas="libhal_device_addon_is_ready">libhal_device_addon_is_ready</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_addon_is_ready        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
HAL addon's must call this method when they are done initializing the device object. The HAL
daemon will wait for all addon's to call this.
</para>
<para>
Can only be used from hald helpers.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique Device Id this addon is handling
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the HAL daemon received the message, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-singleton-addon-is-ready" role="function">
<title>libhal_device_singleton_addon_is_ready ()</title>
<indexterm zone="libhal-device-singleton-addon-is-ready"><primary sortas="libhal_device_singleton_addon_is_ready">libhal_device_singleton_addon_is_ready</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_singleton_addon_is_ready
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *command_line,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
HAL singleton addon's must call this method when they are done initializing the device object. The HAL
daemon will wait for all addon's to call this.
</para>
<para>
Can only be used from hald helpers.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>command_line</parameter>&#160;:</term>
<listitem><simpara> commandline singleton was started with
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE if the HAL daemon received the message, FALSE otherwise
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-acquire-interface-lock" role="function">
<title>libhal_device_acquire_interface_lock ()</title>
<indexterm zone="libhal-device-acquire-interface-lock"><primary sortas="libhal_device_acquire_interface_lock">libhal_device_acquire_interface_lock</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_acquire_interface_lock
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> exclusive,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Releases a lock on an interface for a specific device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface</parameter>&#160;:</term>
<listitem><simpara> the intername name to lock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>exclusive</parameter>&#160;:</term>
<listitem><simpara> whether the lock should be exclusive
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE iff the lock was acquired
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-release-interface-lock" role="function">
<title>libhal_device_release_interface_lock ()</title>
<indexterm zone="libhal-device-release-interface-lock"><primary sortas="libhal_device_release_interface_lock">libhal_device_release_interface_lock</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_release_interface_lock
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Acquires a lock on an interface for a specific device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface</parameter>&#160;:</term>
<listitem><simpara> the intername name to unlock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE iff the lock was released.
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-acquire-global-interface-lock" role="function">
<title>libhal_acquire_global_interface_lock ()</title>
<indexterm zone="libhal-acquire-global-interface-lock"><primary sortas="libhal_acquire_global_interface_lock">libhal_acquire_global_interface_lock</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_acquire_global_interface_lock
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="dbus-bool-t">dbus_bool_t</link> exclusive,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Acquires a global lock on an interface.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface</parameter>&#160;:</term>
<listitem><simpara> the intername name to lock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>exclusive</parameter>&#160;:</term>
<listitem><simpara> whether the lock should be exclusive
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE iff the lock was acquired
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-release-global-interface-lock" role="function">
<title>libhal_release_global_interface_lock ()</title>
<indexterm zone="libhal-release-global-interface-lock"><primary sortas="libhal_release_global_interface_lock">libhal_release_global_interface_lock</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_release_global_interface_lock
                                                        (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Releases a global lock on an interface.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface</parameter>&#160;:</term>
<listitem><simpara> the intername name to unlock
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> TRUE iff the lock was released
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-is-caller-locked-out" role="function">
<title>libhal_device_is_caller_locked_out ()</title>
<indexterm zone="libhal-device-is-caller-locked-out"><primary sortas="libhal_device_is_caller_locked_out">libhal_device_is_caller_locked_out</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_is_caller_locked_out  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         const <link linkend="char">char</link> *caller,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Determines whether a given process on the system message bus is
locked out from an interface on a specific device. Only HAL helpers
are privileged to use this method.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface</parameter>&#160;:</term>
<listitem><simpara> the intername name to check
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>caller</parameter>&#160;:</term>
<listitem><simpara> the caller to check for
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> Whether the given caller is locked out
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-is-locked-by-others" role="function">
<title>libhal_device_is_locked_by_others ()</title>
<indexterm zone="libhal-device-is-locked-by-others"><primary sortas="libhal_device_is_locked_by_others">libhal_device_is_locked_by_others</primary></indexterm><programlisting><link linkend="dbus-bool-t">dbus_bool_t</link>         libhal_device_is_locked_by_others   (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *interface,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Determines whether a determines other processes than the caller holds a lock on the given device.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>interface</parameter>&#160;:</term>
<listitem><simpara> the intername name to check
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors or NULL
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> If another process is holding a lock on the device
</simpara></listitem></varlistentry>
</variablelist></refsect2>
<refsect2 id="libhal-device-is-caller-privileged" role="function">
<title>libhal_device_is_caller_privileged ()</title>
<indexterm zone="libhal-device-is-caller-privileged"><primary sortas="libhal_device_is_caller_privileged">libhal_device_is_caller_privileged</primary></indexterm><programlisting><link linkend="char">char</link>*               libhal_device_is_caller_privileged  (<link linkend="LibHalContext">LibHalContext</link> *ctx,
                                                         const <link linkend="char">char</link> *udi,
                                                         const <link linkend="char">char</link> *action,
                                                         const <link linkend="char">char</link> *caller,
                                                         <link linkend="DBusError">DBusError</link> *error);</programlisting>
<para>
Determines if a given caller have a given privilege on a given
device. Will always error out if HAL is not built with PolicyKit
support.</para>
<para>
</para><variablelist role="params">
<varlistentry><term><parameter>ctx</parameter>&#160;:</term>
<listitem><simpara> the context for the connection to hald
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>udi</parameter>&#160;:</term>
<listitem><simpara> the Unique id of device
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>action</parameter>&#160;:</term>
<listitem><simpara> the action to check for
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>caller</parameter>&#160;:</term>
<listitem><simpara> the caller to check for
</simpara></listitem></varlistentry>
<varlistentry><term><parameter>error</parameter>&#160;:</term>
<listitem><simpara> pointer to an initialized dbus error object for returning errors
</simpara></listitem></varlistentry>
<varlistentry><term><emphasis>Returns</emphasis>&#160;:</term><listitem><simpara> The textual reply from PolicyKit. See the <link linkend="PolicyKitResult"><type>PolicyKitResult</type></link>
enumeration in the PolicyKit documentation for details. The caller
is responsible for freeing this string with the function
<link linkend="libhal-free-string"><function>libhal_free_string()</function></link>.
</simpara></listitem></varlistentry>
</variablelist></refsect2>

</refsect1>




</refentry>