00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifdef HAVE_CONFIG_H
00027 # include <config.h>
00028 #endif
00029
00030 #include <stdlib.h>
00031 #include <stdio.h>
00032 #include <string.h>
00033
00034 #include <dbus/dbus.h>
00035 #include <dbus/dbus-glib.h>
00036
00037 #include "hald.h"
00038 #include "hald_dbus.h"
00039 #include "device.h"
00040 #include "device_store.h"
00041 #include "logger.h"
00042 #include "osspec.h"
00043
00044 static DBusConnection *dbus_connection;
00045
00059 static void
00060 raise_no_such_device (DBusConnection * connection,
00061 DBusMessage * in_reply_to, const char *udi)
00062 {
00063 char buf[512];
00064 DBusMessage *reply;
00065
00066 snprintf (buf, 511, "No device with id %s", udi);
00067 HAL_WARNING ((buf));
00068 reply = dbus_message_new_error (in_reply_to,
00069 "org.freedesktop.Hal.NoSuchDevice",
00070 buf);
00071 if (reply == NULL)
00072 DIE (("No memory"));
00073 if (!dbus_connection_send (connection, reply, NULL))
00074 DIE (("No memory"));
00075 dbus_message_unref (reply);
00076 }
00077
00084 static void
00085 raise_udi_in_use (DBusConnection * connection,
00086 DBusMessage * in_reply_to, const char *udi)
00087 {
00088 char buf[512];
00089 DBusMessage *reply;
00090
00091 snprintf (buf, 511, "Unique device id '%s' is already in use",
00092 udi);
00093 HAL_WARNING ((buf));
00094 reply = dbus_message_new_error (in_reply_to,
00095 "org.freedesktop.Hal.UdiInUse",
00096 buf);
00097 if (reply == NULL)
00098 DIE (("No memory"));
00099 if (!dbus_connection_send (connection, reply, NULL))
00100 DIE (("No memory"));
00101 dbus_message_unref (reply);
00102 }
00103
00111 static void
00112 raise_no_such_property (DBusConnection * connection,
00113 DBusMessage * in_reply_to,
00114 const char *device_id, const char *key)
00115 {
00116 char buf[512];
00117 DBusMessage *reply;
00118
00119 snprintf (buf, 511, "No property %s on device with id %s", key,
00120 device_id);
00121 HAL_WARNING ((buf));
00122 reply = dbus_message_new_error (in_reply_to,
00123 "org.freedesktop.Hal.NoSuchProperty",
00124 buf);
00125 if (reply == NULL)
00126 DIE (("No memory"));
00127 if (!dbus_connection_send (connection, reply, NULL))
00128 DIE (("No memory"));
00129 dbus_message_unref (reply);
00130 }
00131
00139 static void
00140 raise_property_type_error (DBusConnection * connection,
00141 DBusMessage * in_reply_to,
00142 const char *device_id, const char *key)
00143 {
00144 char buf[512];
00145 DBusMessage *reply;
00146
00147 snprintf (buf, 511,
00148 "Type mismatch setting property %s on device with id %s",
00149 key, device_id);
00150 HAL_WARNING ((buf));
00151 reply = dbus_message_new_error (in_reply_to,
00152 "org.freedesktop.Hal.TypeMismatch",
00153 buf);
00154 if (reply == NULL)
00155 DIE (("No memory"));
00156 if (!dbus_connection_send (connection, reply, NULL))
00157 DIE (("No memory"));
00158 dbus_message_unref (reply);
00159 }
00160
00168 static void
00169 raise_syntax (DBusConnection * connection,
00170 DBusMessage * in_reply_to, const char *method_name)
00171 {
00172 char buf[512];
00173 DBusMessage *reply;
00174
00175 snprintf (buf, 511,
00176 "There is a syntax error in the invocation of "
00177 "the method %s", method_name);
00178 HAL_WARNING ((buf));
00179 reply = dbus_message_new_error (in_reply_to,
00180 "org.freedesktop.Hal.SyntaxError",
00181 buf);
00182 if (reply == NULL)
00183 DIE (("No memory"));
00184 if (!dbus_connection_send (connection, reply, NULL))
00185 DIE (("No memory"));
00186 dbus_message_unref (reply);
00187 }
00188
00199 static gboolean
00200 foreach_device_get_udi (HalDeviceStore *store, HalDevice *device,
00201 gpointer user_data)
00202 {
00203 DBusMessageIter *iter = user_data;
00204
00205 dbus_message_iter_append_string (iter, hal_device_get_udi (device));
00206
00207 return TRUE;
00208 }
00209
00220 DBusHandlerResult
00221 manager_get_all_devices (DBusConnection * connection,
00222 DBusMessage * message)
00223 {
00224 DBusMessage *reply;
00225 DBusMessageIter iter;
00226 DBusMessageIter iter_array;
00227
00228 HAL_TRACE (("entering"));
00229
00230 reply = dbus_message_new_method_return (message);
00231 if (reply == NULL)
00232 DIE (("No memory"));
00233
00234 dbus_message_iter_init (reply, &iter);
00235 dbus_message_iter_append_array (&iter, &iter_array,
00236 DBUS_TYPE_STRING);
00237
00238 hal_device_store_foreach (hald_get_gdl (),
00239 foreach_device_get_udi,
00240 &iter_array);
00241
00242 if (!dbus_connection_send (connection, reply, NULL))
00243 DIE (("No memory"));
00244
00245 dbus_message_unref (reply);
00246
00247 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00248 }
00249
00250 typedef struct {
00251 const char *key;
00252 const char *value;
00253 DBusMessageIter *iter;
00254 } DeviceMatchInfo;
00255
00256 static gboolean
00257 foreach_device_match_get_udi (HalDeviceStore *store, HalDevice *device,
00258 gpointer user_data)
00259 {
00260 DeviceMatchInfo *info = user_data;
00261 const char *dev_value;
00262
00263 if (hal_device_property_get_type (device,
00264 info->key) != DBUS_TYPE_STRING)
00265 return TRUE;
00266
00267 dev_value = hal_device_property_get_string (device, info->key);
00268
00269 if (dev_value != NULL && strcmp (dev_value, info->value) == 0) {
00270 dbus_message_iter_append_string (info->iter,
00271 hal_device_get_udi (device));
00272 }
00273
00274 return TRUE;
00275 }
00276
00289 DBusHandlerResult
00290 manager_find_device_string_match (DBusConnection * connection,
00291 DBusMessage * message)
00292 {
00293 DBusMessage *reply;
00294 DBusMessageIter iter;
00295 DBusMessageIter iter_array;
00296 DBusError error;
00297 const char *key;
00298 const char *value;
00299 DeviceMatchInfo info;
00300
00301 HAL_TRACE (("entering"));
00302
00303 dbus_error_init (&error);
00304 if (!dbus_message_get_args (message, &error,
00305 DBUS_TYPE_STRING, &key,
00306 DBUS_TYPE_STRING, &value,
00307 DBUS_TYPE_INVALID)) {
00308 raise_syntax (connection, message,
00309 "Manager.FindDeviceStringMatch");
00310 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00311 }
00312
00313 reply = dbus_message_new_method_return (message);
00314 if (reply == NULL)
00315 DIE (("No memory"));
00316
00317 dbus_message_iter_init (reply, &iter);
00318 dbus_message_iter_append_array (&iter, &iter_array,
00319 DBUS_TYPE_STRING);
00320
00321 info.key = key;
00322 info.iter = &iter_array;
00323
00324 hal_device_store_foreach (hald_get_gdl (),
00325 foreach_device_match_get_udi,
00326 &info);
00327
00328 if (!dbus_connection_send (connection, reply, NULL))
00329 DIE (("No memory"));
00330
00331 dbus_message_unref (reply);
00332
00333 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00334 }
00335
00336 typedef struct {
00337 const char *capability;
00338 DBusMessageIter *iter;
00339 } DeviceCapabilityInfo;
00340
00341 static gboolean
00342 foreach_device_by_capability (HalDeviceStore *store, HalDevice *device,
00343 gpointer user_data)
00344 {
00345 DeviceCapabilityInfo *info = user_data;
00346 const char *caps;
00347
00348 caps = hal_device_property_get_string (device, "info.capabilities");
00349
00350 if (strstr (caps, info->capability) != NULL) {
00351 dbus_message_iter_append_string (info->iter,
00352 hal_device_get_udi (device));
00353 }
00354
00355 return TRUE;
00356 }
00357
00368 DBusHandlerResult
00369 manager_find_device_by_capability (DBusConnection * connection,
00370 DBusMessage * message)
00371 {
00372 DBusMessage *reply;
00373 DBusMessageIter iter;
00374 DBusMessageIter iter_array;
00375 DBusError error;
00376 const char *capability;
00377 DeviceCapabilityInfo info;
00378
00379 HAL_TRACE (("entering"));
00380
00381 dbus_error_init (&error);
00382 if (!dbus_message_get_args (message, &error,
00383 DBUS_TYPE_STRING, &capability,
00384 DBUS_TYPE_INVALID)) {
00385 raise_syntax (connection, message,
00386 "Manager.FindDeviceByCapability");
00387 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00388 }
00389
00390 reply = dbus_message_new_method_return (message);
00391 if (reply == NULL)
00392 DIE (("No memory"));
00393
00394 dbus_message_iter_init (reply, &iter);
00395 dbus_message_iter_append_array (&iter, &iter_array,
00396 DBUS_TYPE_STRING);
00397
00398 info.capability = capability;
00399 info.iter = &iter_array;
00400
00401 hal_device_store_foreach (hald_get_gdl (),
00402 foreach_device_by_capability,
00403 &info);
00404
00405 if (!dbus_connection_send (connection, reply, NULL))
00406 DIE (("No memory"));
00407
00408 dbus_message_unref (reply);
00409
00410 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00411 }
00412
00413
00424 DBusHandlerResult
00425 manager_device_exists (DBusConnection * connection, DBusMessage * message)
00426 {
00427 DBusMessage *reply;
00428 DBusMessageIter iter;
00429 DBusError error;
00430 HalDevice *d;
00431 const char *udi;
00432
00433 dbus_error_init (&error);
00434 if (!dbus_message_get_args (message, &error,
00435 DBUS_TYPE_STRING, &udi,
00436 DBUS_TYPE_INVALID)) {
00437 raise_syntax (connection, message, "Manager.DeviceExists");
00438 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00439 }
00440
00441 HAL_TRACE (("entering, udi=%s", udi));
00442
00443 d = hal_device_store_find (hald_get_gdl (), udi);
00444
00445 reply = dbus_message_new_method_return (message);
00446 dbus_message_iter_init (reply, &iter);
00447 dbus_message_iter_append_boolean (&iter, d != NULL);
00448
00449 if (reply == NULL)
00450 DIE (("No memory"));
00451
00452 if (!dbus_connection_send (connection, reply, NULL))
00453 DIE (("No memory"));
00454
00455 dbus_message_unref (reply);
00456 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00457 }
00458
00464 void
00465 manager_send_signal_device_added (HalDevice *device)
00466 {
00467 const char *udi = hal_device_get_udi (device);
00468 DBusMessage *message;
00469 DBusMessageIter iter;
00470
00471 HAL_TRACE (("entering, udi=%s", udi));
00472
00473 message = dbus_message_new_signal ("/org/freedesktop/Hal/Manager",
00474 "org.freedesktop.Hal.Manager",
00475 "DeviceAdded");
00476
00477 dbus_message_iter_init (message, &iter);
00478 dbus_message_iter_append_string (&iter, udi);
00479
00480 if (!dbus_connection_send (dbus_connection, message, NULL))
00481 DIE (("error broadcasting message"));
00482
00483 dbus_message_unref (message);
00484 }
00485
00491 void
00492 manager_send_signal_device_removed (HalDevice *device)
00493 {
00494 const char *udi = hal_device_get_udi (device);
00495 DBusMessage *message;
00496 DBusMessageIter iter;
00497
00498 HAL_TRACE (("entering, udi=%s", udi));
00499
00500 message = dbus_message_new_signal ("/org/freedesktop/Hal/Manager",
00501 "org.freedesktop.Hal.Manager",
00502 "DeviceRemoved");
00503
00504 dbus_message_iter_init (message, &iter);
00505 dbus_message_iter_append_string (&iter, udi);
00506
00507 if (!dbus_connection_send (dbus_connection, message, NULL))
00508 DIE (("error broadcasting message"));
00509
00510 dbus_message_unref (message);
00511 }
00512
00520 void
00521 manager_send_signal_new_capability (HalDevice *device,
00522 const char *capability)
00523 {
00524 const char *udi = hal_device_get_udi (device);
00525 DBusMessage *message;
00526 DBusMessageIter iter;
00527
00528 HAL_TRACE (("entering, udi=%s, cap=%s", udi, capability));
00529
00530 message = dbus_message_new_signal ("/org/freedesktop/Hal/Manager",
00531 "org.freedesktop.Hal.Manager",
00532 "NewCapability");
00533
00534 dbus_message_iter_init (message, &iter);
00535 dbus_message_iter_append_string (&iter, udi);
00536 dbus_message_iter_append_string (&iter, capability);
00537
00538 if (!dbus_connection_send (dbus_connection, message, NULL))
00539 DIE (("error broadcasting message"));
00540
00541 dbus_message_unref (message);
00542 }
00543
00553 static gboolean
00554 foreach_property_append (HalDevice *device, HalProperty *p,
00555 gpointer user_data)
00556 {
00557 DBusMessageIter *iter = user_data;
00558 const char *key;
00559 int type;
00560
00561 key = hal_property_get_key (p);
00562 type = hal_property_get_type (p);
00563
00564 dbus_message_iter_append_dict_key (iter, key);
00565
00566 switch (type) {
00567 case DBUS_TYPE_STRING:
00568 dbus_message_iter_append_string (iter,
00569 hal_property_get_string (p));
00570 break;
00571 case DBUS_TYPE_INT32:
00572 dbus_message_iter_append_int32 (iter,
00573 hal_property_get_int (p));
00574 break;
00575 case DBUS_TYPE_DOUBLE:
00576 dbus_message_iter_append_double (iter,
00577 hal_property_get_double (p));
00578 break;
00579 case DBUS_TYPE_BOOLEAN:
00580 dbus_message_iter_append_boolean (iter,
00581 hal_property_get_bool (p));
00582 break;
00583
00584 default:
00585 HAL_WARNING (("Unknown property type %d", type));
00586 break;
00587 }
00588
00589 return TRUE;
00590 }
00591
00592
00593
00606 DBusHandlerResult
00607 device_get_all_properties (DBusConnection * connection,
00608 DBusMessage * message)
00609 {
00610 DBusMessage *reply;
00611 DBusMessageIter iter;
00612 DBusMessageIter iter_dict;
00613 HalDevice *d;
00614 const char *udi;
00615
00616 udi = dbus_message_get_path (message);
00617
00618 HAL_TRACE (("entering, udi=%s", udi));
00619
00620 d = hal_device_store_find (hald_get_gdl (), udi);
00621 if (d == NULL) {
00622 raise_no_such_device (connection, message, udi);
00623 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00624 }
00625
00626 reply = dbus_message_new_method_return (message);
00627 if (reply == NULL)
00628 DIE (("No memory"));
00629
00630 dbus_message_iter_init (reply, &iter);
00631 dbus_message_iter_append_dict (&iter, &iter_dict);
00632
00633 hal_device_property_foreach (d,
00634 foreach_property_append,
00635 &iter_dict);
00636
00637 if (!dbus_connection_send (connection, reply, NULL))
00638 DIE (("No memory"));
00639
00640 dbus_message_unref (reply);
00641
00642 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00643 }
00644
00645
00663 DBusHandlerResult
00664 device_get_property (DBusConnection * connection, DBusMessage * message)
00665 {
00666 DBusMessage *reply;
00667 DBusMessageIter iter;
00668 DBusError error;
00669 HalDevice *d;
00670 const char *udi;
00671 char *key;
00672 int type;
00673 HalProperty *p;
00674
00675 udi = dbus_message_get_path (message);
00676
00677 HAL_TRACE (("entering, udi=%s", udi));
00678
00679 d = hal_device_store_find (hald_get_gdl (), udi);
00680 if (d == NULL) {
00681 raise_no_such_device (connection, message, udi);
00682 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00683 }
00684
00685 dbus_error_init (&error);
00686 if (!dbus_message_get_args (message, &error,
00687 DBUS_TYPE_STRING, &key,
00688 DBUS_TYPE_INVALID)) {
00689 raise_syntax (connection, message, "GetProperty");
00690 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00691 }
00692
00693 p = hal_device_property_find (d, key);
00694 if (p == NULL) {
00695 raise_no_such_property (connection, message, udi, key);
00696 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00697 }
00698
00699 reply = dbus_message_new_method_return (message);
00700 if (reply == NULL)
00701 DIE (("No memory"));
00702
00703 dbus_message_iter_init (reply, &iter);
00704
00705 type = hal_property_get_type (p);
00706 switch (type) {
00707 case DBUS_TYPE_STRING:
00708 dbus_message_iter_append_string (&iter,
00709 hal_property_get_string (p));
00710 break;
00711 case DBUS_TYPE_INT32:
00712 dbus_message_iter_append_int32 (&iter,
00713 hal_property_get_int (p));
00714 break;
00715 case DBUS_TYPE_DOUBLE:
00716 dbus_message_iter_append_double (&iter,
00717 hal_property_get_double (p));
00718 break;
00719 case DBUS_TYPE_BOOLEAN:
00720 dbus_message_iter_append_boolean (&iter,
00721 hal_property_get_bool (p));
00722 break;
00723
00724 default:
00725 HAL_WARNING (("Unknown property type %d", type));
00726 break;
00727 }
00728
00729 if (!dbus_connection_send (connection, reply, NULL))
00730 DIE (("No memory"));
00731
00732 dbus_message_unref (reply);
00733
00734 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00735 }
00736
00737
00751 DBusHandlerResult
00752 device_get_property_type (DBusConnection * connection,
00753 DBusMessage * message)
00754 {
00755 DBusMessage *reply;
00756 DBusMessageIter iter;
00757 DBusError error;
00758 HalDevice *d;
00759 const char *udi;
00760 char *key;
00761 HalProperty *p;
00762
00763 udi = dbus_message_get_path (message);
00764
00765 HAL_TRACE (("entering, udi=%s", udi));
00766
00767 d = hal_device_store_find (hald_get_gdl (), udi);
00768 if (d == NULL) {
00769 raise_no_such_device (connection, message, udi);
00770 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00771 }
00772
00773 dbus_error_init (&error);
00774 if (!dbus_message_get_args (message, &error,
00775 DBUS_TYPE_STRING, &key,
00776 DBUS_TYPE_INVALID)) {
00777 raise_syntax (connection, message, "GetPropertyType");
00778 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00779 }
00780
00781 p = hal_device_property_find (d, key);
00782 if (p == NULL) {
00783 raise_no_such_property (connection, message, udi, key);
00784 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00785 }
00786
00787 reply = dbus_message_new_method_return (message);
00788 if (reply == NULL)
00789 DIE (("No memory"));
00790
00791 dbus_message_iter_init (reply, &iter);
00792 dbus_message_iter_append_int32 (&iter,
00793 hal_property_get_type (p));
00794
00795 if (!dbus_connection_send (connection, reply, NULL))
00796 DIE (("No memory"));
00797
00798 dbus_message_unref (reply);
00799
00800 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00801 }
00802
00803
00804
00823 DBusHandlerResult
00824 device_set_property (DBusConnection * connection, DBusMessage * message)
00825 {
00826 const char *udi;
00827 char *key;
00828 int type;
00829 dbus_bool_t rc;
00830 HalDevice *device;
00831 DBusMessageIter iter;
00832 DBusMessage *reply;
00833
00834 HAL_TRACE (("entering"));
00835
00836 udi = dbus_message_get_path (message);
00837
00838 dbus_message_iter_init (message, &iter);
00839 type = dbus_message_iter_get_arg_type (&iter);
00840 if (type != DBUS_TYPE_STRING) {
00841 raise_syntax (connection, message, "SetProperty");
00842 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00843 }
00844 key = dbus_message_iter_get_string (&iter);
00845
00846 HAL_DEBUG (("udi=%s, key=%s", udi, key));
00847
00848 device = hal_device_store_find (hald_get_gdl (), udi);
00849 if (device == NULL) {
00850 raise_no_such_device (connection, message, udi);
00851 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00852 }
00853 dbus_message_iter_next (&iter);
00854
00857 type = dbus_message_iter_get_arg_type (&iter);
00858 rc = FALSE;
00859 switch (type) {
00860 case DBUS_TYPE_STRING:
00861 rc = hal_device_property_set_string (device, key,
00862 dbus_message_iter_get_string
00863 (&iter));
00864 break;
00865 case DBUS_TYPE_INT32:
00866 rc = hal_device_property_set_int (device, key,
00867 dbus_message_iter_get_int32
00868 (&iter));
00869 break;
00870 case DBUS_TYPE_DOUBLE:
00871 rc = hal_device_property_set_double (device, key,
00872 dbus_message_iter_get_double
00873 (&iter));
00874 break;
00875 case DBUS_TYPE_BOOLEAN:
00876 rc = hal_device_property_set_bool (device, key,
00877 dbus_message_iter_get_boolean
00878 (&iter));
00879 break;
00880
00881 default:
00882 HAL_WARNING (("Unsupported property type %d", type));
00883 break;
00884 }
00885
00886 if (!rc) {
00887 raise_property_type_error (connection, message, udi, key);
00888 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00889 }
00890
00891 reply = dbus_message_new_method_return (message);
00892 if (reply == NULL)
00893 DIE (("No memory"));
00894
00895 if (!dbus_connection_send (connection, reply, NULL))
00896 DIE (("No memory"));
00897
00898 dbus_message_unref (reply);
00899 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00900 }
00901
00902
00904 #define MAX_CAP_SIZE 2048
00905
00932 DBusHandlerResult
00933 device_add_capability (DBusConnection * connection, DBusMessage * message)
00934 {
00935 const char *udi;
00936 const char *capability;
00937 const char *caps;
00938 HalDevice *d;
00939 DBusMessage *reply;
00940 DBusError error;
00941 char buf[MAX_CAP_SIZE];
00942
00943 HAL_TRACE (("entering"));
00944
00945 udi = dbus_message_get_path (message);
00946
00947 d = hal_device_store_find (hald_get_gdl (), udi);
00948 if (d == NULL) {
00949 raise_no_such_device (connection, message, udi);
00950 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00951 }
00952
00953 dbus_error_init (&error);
00954 if (!dbus_message_get_args (message, &error,
00955 DBUS_TYPE_STRING, &capability,
00956 DBUS_TYPE_INVALID)) {
00957 raise_syntax (connection, message, "AddCapability");
00958 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00959 }
00960
00961
00962 caps = hal_device_property_get_string (d, "info.capabilities");
00963 if (caps == NULL) {
00964 hal_device_property_set_string (d, "info.capabilities",
00965 capability);
00966 } else {
00967 if (strstr (caps, capability) == NULL) {
00968 snprintf (buf, MAX_CAP_SIZE, "%s %s", caps,
00969 capability);
00970 hal_device_property_set_string (d, "info.capabilities",
00971 buf);
00972 }
00973 }
00974
00975 manager_send_signal_new_capability (d, capability);
00976
00977 reply = dbus_message_new_method_return (message);
00978 if (reply == NULL)
00979 DIE (("No memory"));
00980
00981 if (!dbus_connection_send (connection, reply, NULL))
00982 DIE (("No memory"));
00983
00984 dbus_message_unref (reply);
00985 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
00986 }
00987
00988
00989
01003 DBusHandlerResult
01004 device_remove_property (DBusConnection * connection, DBusMessage * message)
01005 {
01006 const char *udi;
01007 char *key;
01008 HalDevice *d;
01009 DBusMessage *reply;
01010 DBusError error;
01011
01012 HAL_TRACE (("entering"));
01013
01014 udi = dbus_message_get_path (message);
01015
01016 d = hal_device_store_find (hald_get_gdl (), udi);
01017 if (d == NULL) {
01018 raise_no_such_device (connection, message, udi);
01019 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01020 }
01021
01022 dbus_error_init (&error);
01023 if (!dbus_message_get_args (message, &error,
01024 DBUS_TYPE_STRING, &key,
01025 DBUS_TYPE_INVALID)) {
01026 raise_syntax (connection, message, "RemoveProperty");
01027 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01028 }
01029
01030 if (!hal_device_property_remove (d, key)) {
01031 raise_no_such_property (connection, message, udi, key);
01032 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01033 }
01034
01035
01036 reply = dbus_message_new_method_return (message);
01037 if (reply == NULL)
01038 DIE (("No memory"));
01039
01040 if (!dbus_connection_send (connection, reply, NULL))
01041 DIE (("No memory"));
01042
01043 dbus_message_unref (reply);
01044 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01045 }
01046
01047
01060 DBusHandlerResult
01061 device_property_exists (DBusConnection * connection, DBusMessage * message)
01062 {
01063 const char *udi;
01064 char *key;
01065 HalDevice *d;
01066 DBusMessage *reply;
01067 DBusError error;
01068 DBusMessageIter iter;
01069
01070 HAL_TRACE (("entering"));
01071
01072 udi = dbus_message_get_path (message);
01073
01074 d = hal_device_store_find (hald_get_gdl (), udi);
01075 if (d == NULL) {
01076 raise_no_such_device (connection, message, udi);
01077 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01078 }
01079
01080 dbus_error_init (&error);
01081 if (!dbus_message_get_args (message, &error,
01082 DBUS_TYPE_STRING, &key,
01083 DBUS_TYPE_INVALID)) {
01084 raise_syntax (connection, message, "RemoveProperty");
01085 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01086 }
01087
01088 reply = dbus_message_new_method_return (message);
01089 if (reply == NULL)
01090 DIE (("No memory"));
01091
01092 dbus_message_iter_init (reply, &iter);
01093 dbus_message_iter_append_boolean (&iter,
01094 hal_device_has_property (d, key));
01095
01096 if (!dbus_connection_send (connection, reply, NULL))
01097 DIE (("No memory"));
01098
01099 dbus_message_unref (reply);
01100 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01101 }
01102
01103
01116 DBusHandlerResult
01117 device_query_capability (DBusConnection * connection,
01118 DBusMessage * message)
01119 {
01120 dbus_bool_t rc;
01121 const char *udi;
01122 const char *caps;
01123 char *capability;
01124 HalDevice *d;
01125 DBusMessage *reply;
01126 DBusError error;
01127 DBusMessageIter iter;
01128
01129 HAL_TRACE (("entering"));
01130
01131 udi = dbus_message_get_path (message);
01132
01133 d = hal_device_store_find (hald_get_gdl (), udi);
01134 if (d == NULL) {
01135 raise_no_such_device (connection, message, udi);
01136 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01137 }
01138
01139 dbus_error_init (&error);
01140 if (!dbus_message_get_args (message, &error,
01141 DBUS_TYPE_STRING, &capability,
01142 DBUS_TYPE_INVALID)) {
01143 raise_syntax (connection, message, "QueryCapability");
01144 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01145 }
01146
01147 reply = dbus_message_new_method_return (message);
01148 if (reply == NULL)
01149 DIE (("No memory"));
01150
01151 rc = FALSE;
01152 caps = hal_device_property_get_string (d, "info.capabilities");
01153 if (caps != NULL) {
01154 if (strstr (caps, capability) != NULL)
01155 rc = TRUE;
01156 }
01157
01158 dbus_message_iter_init (reply, &iter);
01159 dbus_message_iter_append_boolean (&iter, rc);
01160
01161 if (!dbus_connection_send (connection, reply, NULL))
01162 DIE (("No memory"));
01163
01164 dbus_message_unref (reply);
01165 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01166 }
01167
01169 static int atomic_count = 0;
01170
01172 static int num_pending_updates = 0;
01173
01175 typedef struct PendingUpdate_s {
01176 char *udi;
01177 char *key;
01178 dbus_bool_t removed;
01179 dbus_bool_t added;
01180 struct PendingUpdate_s *next;
01181 } PendingUpdate;
01182
01183 static PendingUpdate *pending_updates_head = NULL;
01184
01190 void
01191 device_property_atomic_update_begin (void)
01192 {
01193 atomic_count++;
01194 }
01195
01200 void
01201 device_property_atomic_update_end (void)
01202 {
01203 PendingUpdate *pu_iter = NULL;
01204 PendingUpdate *pu_iter_next = NULL;
01205 PendingUpdate *pu_iter2 = NULL;
01206
01207 --atomic_count;
01208
01209 if (atomic_count < 0) {
01210 HAL_WARNING (("*** atomic_count = %d < 0 !!",
01211 atomic_count));
01212 atomic_count = 0;
01213 }
01214
01215 if (atomic_count == 0 && num_pending_updates > 0) {
01216 DBusMessage *message;
01217 DBusMessageIter iter;
01218
01219 for (pu_iter = pending_updates_head;
01220 pu_iter != NULL; pu_iter = pu_iter_next) {
01221 int num_updates_this;
01222
01223 pu_iter_next = pu_iter->next;
01224
01225 if (pu_iter->udi == NULL)
01226 goto have_processed;
01227
01228
01229 num_updates_this = 0;
01230 for (pu_iter2 = pu_iter;
01231 pu_iter2 != NULL; pu_iter2 = pu_iter2->next) {
01232 if (strcmp (pu_iter2->udi, pu_iter->udi) == 0)
01233 num_updates_this++;
01234 }
01235
01236
01237 message = dbus_message_new_signal (
01238 pu_iter->udi,
01239 "org.freedesktop.Hal.Device",
01240 "PropertyModified");
01241 dbus_message_iter_init (message, &iter);
01242 dbus_message_iter_append_int32 (&iter,
01243 num_updates_this);
01244 for (pu_iter2 = pu_iter; pu_iter2 != NULL;
01245 pu_iter2 = pu_iter2->next) {
01246 if (strcmp (pu_iter2->udi, pu_iter->udi) == 0) {
01247 dbus_message_iter_append_string
01248 (&iter, pu_iter2->key);
01249 dbus_message_iter_append_boolean
01250 (&iter, pu_iter2->removed);
01251 dbus_message_iter_append_boolean
01252 (&iter, pu_iter2->added);
01253
01254
01255 if (pu_iter2 != pu_iter) {
01256 g_free (pu_iter2->udi);
01257 pu_iter2->udi = NULL;
01258 }
01259 }
01260 }
01261
01262
01263 if (!dbus_connection_send
01264 (dbus_connection, message, NULL))
01265 DIE (("error broadcasting message"));
01266
01267 dbus_message_unref (message);
01268
01269 have_processed:
01270 g_free (pu_iter->key);
01271 g_free (pu_iter);
01272 }
01273
01274 num_pending_updates = 0;
01275 pending_updates_head = NULL;
01276 }
01277 }
01278
01279
01280
01281 void
01282 device_send_signal_property_modified (HalDevice *device, const char *key,
01283 dbus_bool_t added, dbus_bool_t removed)
01284 {
01285 const char *udi = hal_device_get_udi (device);
01286 DBusMessage *message;
01287 DBusMessageIter iter;
01288
01289
01290
01291
01292
01293
01294
01295
01296
01297 if (atomic_count > 0) {
01298 PendingUpdate *pu;
01299
01300 pu = g_new0 (PendingUpdate, 1);
01301 pu->udi = g_strdup (udi);
01302 pu->key = g_strdup (key);
01303 pu->removed = removed;
01304 pu->added = added;
01305 pu->next = pending_updates_head;
01306
01307 pending_updates_head = pu;
01308 num_pending_updates++;
01309 } else {
01310 message = dbus_message_new_signal (udi,
01311 "org.freedesktop.Hal.Device",
01312 "PropertyModified");
01313
01314 dbus_message_iter_init (message, &iter);
01315 dbus_message_iter_append_int32 (&iter, 1);
01316 dbus_message_iter_append_string (&iter, key);
01317 dbus_message_iter_append_boolean (&iter, removed);
01318 dbus_message_iter_append_boolean (&iter, added);
01319
01320 if (!dbus_connection_send (dbus_connection, message, NULL))
01321 DIE (("error broadcasting message"));
01322
01323 dbus_message_unref (message);
01324 }
01325 }
01326
01346 void
01347 device_send_signal_condition (HalDevice *device, const char *condition_name,
01348 int first_arg_type, ...)
01349 {
01350 const char *udi = hal_device_get_udi (device);
01351 DBusMessage *message;
01352 DBusMessageIter iter;
01353 va_list var_args;
01354
01355 message = dbus_message_new_signal (udi,
01356 "org.freedesktop.Hal.Device",
01357 "Condition");
01358 dbus_message_iter_init (message, &iter);
01359 dbus_message_iter_append_string (&iter, condition_name);
01360
01361 va_start (var_args, first_arg_type);
01362 dbus_message_append_args_valist (message, first_arg_type,
01363 var_args);
01364 va_end (var_args);
01365
01366 if (!dbus_connection_send (dbus_connection, message, NULL))
01367 DIE (("error broadcasting message"));
01368
01369 dbus_message_unref (message);
01370 }
01371
01372
01373
01397 DBusHandlerResult
01398 agent_manager_new_device (DBusConnection * connection,
01399 DBusMessage * message)
01400 {
01401 HalDevice *d;
01402 DBusMessage *reply;
01403 DBusMessageIter iter;
01404 const char *udi;
01405
01406 HAL_TRACE (("entering"));
01407
01408 reply = dbus_message_new_method_return (message);
01409 if (reply == NULL)
01410 DIE (("No memory"));
01411
01412 d = hal_device_new ();
01413 udi = hal_device_get_udi (d);
01414
01415 HAL_TRACE (("udi=%s", udi));
01416
01417 dbus_message_iter_init (reply, &iter);
01418 dbus_message_iter_append_string (&iter, udi);
01419
01420 if (!dbus_connection_send (connection, reply, NULL))
01421 DIE (("No memory"));
01422
01423 dbus_message_unref (reply);
01424
01425 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01426 }
01427
01450 DBusHandlerResult
01451 agent_manager_commit_to_gdl (DBusConnection * connection,
01452 DBusMessage * message)
01453 {
01454 DBusMessage *reply;
01455 DBusError error;
01456 HalDevice *d;
01457 const char *old_udi;
01458 const char *new_udi;
01459
01460 dbus_error_init (&error);
01461 if (!dbus_message_get_args (message, &error,
01462 DBUS_TYPE_STRING, &old_udi,
01463 DBUS_TYPE_STRING, &new_udi,
01464 DBUS_TYPE_INVALID)) {
01465 raise_syntax (connection, message, "CommitToGdl");
01466 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01467 }
01468
01469 HAL_TRACE (("entering, old_udi=%s, new_udi=%s", old_udi, new_udi));
01470
01471 d = hal_device_store_find (hald_get_gdl (), old_udi);
01472 if (d == NULL) {
01473 raise_no_such_device (connection, message, old_udi);
01474 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01475 }
01476
01477 if (hal_device_store_find (hald_get_gdl (), new_udi) != NULL) {
01478 raise_udi_in_use (connection, message, new_udi);
01479 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01480 }
01481
01482
01483 hal_device_store_add (hald_get_gdl (), d);
01484
01485
01486
01487
01488
01489 reply = dbus_message_new_method_return (message);
01490 if (reply == NULL)
01491 DIE (("No memory"));
01492
01493 if (!dbus_connection_send (connection, reply, NULL))
01494 DIE (("No memory"));
01495
01496 dbus_message_unref (reply);
01497 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01498 }
01499
01500
01517 DBusHandlerResult
01518 agent_manager_remove (DBusConnection * connection, DBusMessage * message)
01519 {
01520 DBusMessage *reply;
01521 DBusError error;
01522 HalDevice *d;
01523 const char *udi;
01524
01525 dbus_error_init (&error);
01526 if (!dbus_message_get_args (message, &error,
01527 DBUS_TYPE_STRING, &udi,
01528 DBUS_TYPE_INVALID)) {
01529 raise_syntax (connection, message, "Remove");
01530 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01531 }
01532
01533 HAL_INFO (("entering, udi=%s", udi));
01534
01535 d = hal_device_store_find (hald_get_gdl (), udi);
01536 if (d == NULL) {
01537 raise_no_such_device (connection, message, udi);
01538 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01539 }
01540
01541 g_object_unref (d);
01542
01543
01544
01545
01546
01547
01548
01549 reply = dbus_message_new_method_return (message);
01550 if (reply == NULL)
01551 DIE (("No memory"));
01552
01553 if (!dbus_connection_send (connection, reply, NULL))
01554 DIE (("No memory"));
01555
01556 dbus_message_unref (reply);
01557 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01558 }
01559
01560
01561
01575 DBusHandlerResult
01576 agent_merge_properties (DBusConnection * connection, DBusMessage * message)
01577 {
01578 DBusMessage *reply;
01579 DBusError error;
01580 HalDevice *target_d;
01581 HalDevice *source_d;
01582 const char *target_udi;
01583 const char *source_udi;
01584
01585 dbus_error_init (&error);
01586 if (!dbus_message_get_args (message, &error,
01587 DBUS_TYPE_STRING, &target_udi,
01588 DBUS_TYPE_STRING, &source_udi,
01589 DBUS_TYPE_INVALID)) {
01590 raise_syntax (connection, message, "MergeProperties");
01591 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01592 }
01593
01594 HAL_TRACE (("entering, target_udi=%s, source_udi=%s",
01595 target_udi, source_udi));
01596
01597 target_d = hal_device_store_find (hald_get_gdl (), target_udi);
01598 if (target_d == NULL) {
01599 raise_no_such_device (connection, message, target_udi);
01600 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01601 }
01602
01603 source_d = hal_device_store_find (hald_get_gdl (), source_udi);
01604 if (source_d == NULL) {
01605 raise_no_such_device (connection, message, source_udi);
01606 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01607 }
01608
01609 hal_device_merge (target_d, source_d);
01610
01611 reply = dbus_message_new_method_return (message);
01612 if (reply == NULL)
01613 DIE (("No memory"));
01614
01615 if (!dbus_connection_send (connection, reply, NULL))
01616 DIE (("No memory"));
01617
01618 dbus_message_unref (reply);
01619 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01620 }
01621
01622
01645 DBusHandlerResult
01646 agent_device_matches (DBusConnection * connection, DBusMessage * message)
01647 {
01648 DBusMessage *reply;
01649 DBusError error;
01650 HalDevice *d1;
01651 HalDevice *d2;
01652 const char *udi1;
01653 const char *udi2;
01654 const char *namespace;
01655 dbus_bool_t rc;
01656 DBusMessageIter iter;
01657
01658 dbus_error_init (&error);
01659 if (!dbus_message_get_args (message, &error,
01660 DBUS_TYPE_STRING, &udi1,
01661 DBUS_TYPE_STRING, &udi2,
01662 DBUS_TYPE_STRING, &namespace,
01663 DBUS_TYPE_INVALID)) {
01664 raise_syntax (connection, message, "DeviceMatches");
01665 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01666 }
01667
01668 HAL_TRACE (("entering, udi1=%s, udi2=%s, namespace=%s",
01669 udi1, udi2, namespace));
01670
01671 d1 = hal_device_store_find (hald_get_gdl (), udi1);
01672 if (d1 == NULL) {
01673 raise_no_such_device (connection, message, udi1);
01674 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01675 }
01676
01677 d2 = hal_device_store_find (hald_get_gdl (), udi2);
01678 if (d2 == NULL) {
01679 raise_no_such_device (connection, message, udi2);
01680 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01681 }
01682
01683 rc = hal_device_matches (d1, d2, namespace);
01684
01685 reply = dbus_message_new_method_return (message);
01686 if (reply == NULL)
01687 DIE (("No memory"));
01688
01689 dbus_message_iter_init (reply, &iter);
01690 dbus_message_iter_append_boolean (&iter, rc);
01691
01692 if (!dbus_connection_send (connection, reply, NULL))
01693 DIE (("No memory"));
01694
01695 dbus_message_unref (reply);
01696 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01697 }
01698
01707 static DBusHandlerResult
01708 filter_function (DBusConnection * connection,
01709 DBusMessage * message, void *user_data)
01710 {
01711
01712
01713
01714
01715
01716
01717
01718 if (dbus_message_is_method_call (message,
01719 "org.freedesktop.Hal.Manager",
01720 "GetAllDevices") &&
01721 strcmp (dbus_message_get_path (message),
01722 "/org/freedesktop/Hal/Manager") == 0) {
01723 return manager_get_all_devices (connection, message);
01724 } else if (dbus_message_is_method_call (message,
01725 "org.freedesktop.Hal.Manager",
01726 "DeviceExists") &&
01727 strcmp (dbus_message_get_path (message),
01728 "/org/freedesktop/Hal/Manager") == 0) {
01729 return manager_device_exists (connection, message);
01730 } else if (dbus_message_is_method_call (message,
01731 "org.freedesktop.Hal.Manager",
01732 "FindDeviceStringMatch") &&
01733 strcmp (dbus_message_get_path (message),
01734 "/org/freedesktop/Hal/Manager") == 0) {
01735 return manager_find_device_string_match (connection,
01736 message);
01737 } else
01738 if (dbus_message_is_method_call
01739 (message, "org.freedesktop.Hal.Manager",
01740 "FindDeviceByCapability")
01741 && strcmp (dbus_message_get_path (message),
01742 "/org/freedesktop/Hal/Manager") == 0) {
01743 return manager_find_device_by_capability (connection,
01744 message);
01745 }
01746
01747 else if (dbus_message_is_method_call (message,
01748 "org.freedesktop.Hal.AgentManager",
01749 "NewDevice") &&
01750 strcmp (dbus_message_get_path (message),
01751 "/org/freedesktop/Hal/Manager") == 0) {
01752 return agent_manager_new_device (connection, message);
01753 } else if (dbus_message_is_method_call (message,
01754 "org.freedesktop.Hal.AgentManager",
01755 "CommitToGdl") &&
01756 strcmp (dbus_message_get_path (message),
01757 "/org/freedesktop/Hal/Manager") == 0) {
01758 return agent_manager_commit_to_gdl (connection, message);
01759 } else if (dbus_message_is_method_call (message,
01760 "org.freedesktop.Hal.AgentManager",
01761 "Remove") &&
01762 strcmp (dbus_message_get_path (message),
01763 "/org/freedesktop/Hal/Manager") == 0) {
01764 return agent_manager_remove (connection, message);
01765 } else if (dbus_message_is_method_call (message,
01766 "org.freedesktop.Hal.AgentManager",
01767 "MergeProperties") &&
01768 strcmp (dbus_message_get_path (message),
01769 "/org/freedesktop/Hal/Manager") == 0) {
01770 return agent_merge_properties (connection, message);
01771 } else if (dbus_message_is_method_call (message,
01772 "org.freedesktop.Hal.AgentManager",
01773 "DeviceMatches") &&
01774 strcmp (dbus_message_get_path (message),
01775 "/org/freedesktop/Hal/Manager") == 0) {
01776 return agent_device_matches (connection, message);
01777 }
01778
01779
01780 else if (dbus_message_is_method_call (message,
01781 "org.freedesktop.Hal.Device",
01782 "GetAllProperties")) {
01783 return device_get_all_properties (connection, message);
01784 } else if (dbus_message_is_method_call (message,
01785 "org.freedesktop.Hal.Device",
01786 "GetProperty")) {
01787 return device_get_property (connection, message);
01788 } else if (dbus_message_is_method_call (message,
01789 "org.freedesktop.Hal.Device",
01790 "GetPropertyString")) {
01791 return device_get_property (connection, message);
01792 } else if (dbus_message_is_method_call (message,
01793 "org.freedesktop.Hal.Device",
01794 "GetPropertyInteger")) {
01795 return device_get_property (connection, message);
01796 } else if (dbus_message_is_method_call (message,
01797 "org.freedesktop.Hal.Device",
01798 "GetPropertyBoolean")) {
01799 return device_get_property (connection, message);
01800 } else if (dbus_message_is_method_call (message,
01801 "org.freedesktop.Hal.Device",
01802 "GetPropertyDouble")) {
01803 return device_get_property (connection, message);
01804 } else if (dbus_message_is_method_call (message,
01805 "org.freedesktop.Hal.Device",
01806 "SetProperty")) {
01807 return device_set_property (connection, message);
01808 } else if (dbus_message_is_method_call (message,
01809 "org.freedesktop.Hal.Device",
01810 "SetPropertyString")) {
01811 return device_set_property (connection, message);
01812 } else if (dbus_message_is_method_call (message,
01813 "org.freedesktop.Hal.Device",
01814 "SetPropertyInteger")) {
01815 return device_set_property (connection, message);
01816 } else if (dbus_message_is_method_call (message,
01817 "org.freedesktop.Hal.Device",
01818 "SetPropertyBoolean")) {
01819 return device_set_property (connection, message);
01820 } else if (dbus_message_is_method_call (message,
01821 "org.freedesktop.Hal.Device",
01822 "SetPropertyDouble")) {
01823 return device_set_property (connection, message);
01824 } else if (dbus_message_is_method_call (message,
01825 "org.freedesktop.Hal.Device",
01826 "RemoveProperty")) {
01827 return device_remove_property (connection, message);
01828 } else if (dbus_message_is_method_call (message,
01829 "org.freedesktop.Hal.Device",
01830 "GetPropertyType")) {
01831 return device_get_property_type (connection, message);
01832 } else if (dbus_message_is_method_call (message,
01833 "org.freedesktop.Hal.Device",
01834 "PropertyExists")) {
01835 return device_property_exists (connection, message);
01836 } else if (dbus_message_is_method_call (message,
01837 "org.freedesktop.Hal.Device",
01838 "AddCapability")) {
01839 return device_add_capability (connection, message);
01840 } else if (dbus_message_is_method_call (message,
01841 "org.freedesktop.Hal.Device",
01842 "QueryCapability")) {
01843 return device_query_capability (connection, message);
01844 } else
01845 osspec_filter_function (connection, message, user_data);
01846
01847 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
01848 }
01849
01850 DBusConnection *
01851 hald_dbus_init (void)
01852 {
01853 DBusError dbus_error;
01854
01855 dbus_connection_set_change_sigpipe (TRUE);
01856
01857 dbus_error_init (&dbus_error);
01858 dbus_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error);
01859 if (dbus_connection == NULL) {
01860 HAL_ERROR (("dbus_bus_get(): %s", dbus_error.message));
01861 exit (1);
01862 }
01863
01864 dbus_connection_setup_with_g_main (dbus_connection, NULL);
01865
01866 dbus_bus_acquire_service (dbus_connection, "org.freedesktop.Hal",
01867 0, &dbus_error);
01868 if (dbus_error_is_set (&dbus_error)) {
01869 HAL_ERROR (("dbus_bus_acquire_service(): %s",
01870 dbus_error.message));
01871 exit (1);
01872 }
01873
01874 dbus_connection_add_filter (dbus_connection, filter_function, NULL,
01875 NULL);
01876
01877 return dbus_connection;
01878 }
01879