Main Page | Modules | Data Structures | File List | Data Fields | Related Pages

hald_dbus.c

00001 /***************************************************************************
00002  * CVSID: $Id: hald_dbus.c,v 1.2 2004/04/03 07:46:33 david Exp $
00003  *
00004  * dbus.c : D-BUS interface of HAL daemon
00005  *
00006  * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
00007  *
00008  * Licensed under the Academic Free License version 2.0
00009  *
00010  * This program is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU General Public License
00021  * along with this program; if not, write to the Free Software
00022  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
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             /* count number of updates for this device */
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             /* prepare message */
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                     /* signal this is already processed */
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         }       /* for all updates */
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     HAL_INFO(("Entering, udi=%s, key=%s, in_gdl=%s, removed=%s added=%s",
01291               device->udi, key, 
01292               in_gdl ? "true" : "false",
01293               removed ? "true" : "false",
01294               added ? "true" : "false"));
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     /* add to the GDL */
01483     hal_device_store_add (hald_get_gdl (), d);
01484 
01485     /* Ok, send out a signal on the Manager interface that we added
01486      * this device to the gdl */
01487     /*manager_send_signal_device_added(new_udi); */
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     /* Ok, send out a signal on the Manager interface that we removed
01544      * this device from the gdl */
01545     /*
01546        manager_send_signal_device_removed(udi);
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     HAL_INFO (("obj_path=%s interface=%s method=%s", 
01713     dbus_message_get_path(message), 
01714     dbus_message_get_interface(message),
01715     dbus_message_get_member(message)));
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 

Generated on Sat Apr 24 19:57:45 2004 for HAL by doxygen 1.3.6-20040222