git.maemo.org Git - mtetherd/blob - hal.c

   1 /*
   2   mtetherd
   3   (c) 2010 Gregor Riepl <onitake@gmail.com>
   4
   5   Tethering utility for Maemo
   6
   7   This program is free software: you can redistribute it and/or modify
   8   it under the terms of the GNU General Public License as published by
   9   the Free Software Foundation, either version 3 of the License, or
  10   (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <string.h>
  22 #include "hal.h"
  23 #include "net.h"
  24 #include "plugin.h"
  25
  26 static const char *USBDEV_PATH = "/org/freedesktop/Hal/devices/usb_device_1d6b_2_musb_hdrc";
  27
  28 static void mtetherd_hal_device_condition(LibHalContext *ctx, const char *udi, const char *condition, const char *detail) {
  29         MTetherDStatusPlugin *plugin = MTETHERD_STATUS_PLUGIN(libhal_ctx_get_user_data(ctx));
  30
  31         if (plugin) {
  32                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Got HAL condition %s on %s: %s", condition, udi, detail);
  33                 if (g_strcmp0("ButtonPressed", condition) == 0) {
  34                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "is ButtonPressed");
  35                         if (g_strcmp0(USBDEV_PATH, udi) == 0) {
  36                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "is %s", USBDEV_PATH);
  37                                 mtetherd_status_plugin_usb_plugged(plugin);
  38                         }
  39                 }
  40         }
  41 }
  42
  43 static void mtetherd_hal_device_added(LibHalContext *ctx, const char *udi) {
  44         MTetherDStatusPlugin *plugin = MTETHERD_STATUS_PLUGIN(libhal_ctx_get_user_data(ctx));
  45
  46         if (plugin) {
  47                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Got HAL device added on %s", udi);
  48                 DBusError derr;
  49                 dbus_error_init(&derr);
  50                 char *interface = libhal_device_get_property_string(plugin->hal_context, udi, "net.interface", &derr);
  51                 if (dbus_error_is_set(&derr)) {
  52                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error getting interface name of %s (%s): %s", udi, derr.name, derr.message);
  53                         dbus_error_free(&derr);
  54                 }
  55                 if (interface) {
  56                         MTetherDDevice *device = mtetherd_device_new(interface, udi);
  57                         if (device) {
  58                                 mtetherd_status_plugin_device_added(plugin, device);
  59                         }
  60                         libhal_free_string(interface);
  61                 }
  62         }
  63 }
  64
  65 static void mtetherd_hal_device_removed(LibHalContext *ctx, const char *udi) {
  66         MTetherDStatusPlugin *plugin = MTETHERD_STATUS_PLUGIN(libhal_ctx_get_user_data(ctx));
  67
  68         if (plugin) {
  69                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Got HAL device removed on %s", udi);
  70                 mtetherd_status_plugin_device_removed(plugin, udi);
  71         }
  72 }
  73
  74 gboolean mtetherd_hal_init(MTetherDStatusPlugin *plugin) {
  75         if (plugin) {
  76                 GError *err = NULL;
  77                 plugin->dbus_connection = hd_status_plugin_item_get_dbus_g_connection(HD_STATUS_PLUGIN_ITEM(plugin), DBUS_BUS_SYSTEM, &err);
  78                 if (err) {
  79                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't open DBUS connection: %s", err->message);
  80                         g_error_free(err);
  81                         err = NULL;
  82                         return FALSE;
  83                 } else {
  84                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Got GDBUS connection: %p", plugin->dbus_connection);
  85                 }
  86                 if (plugin->dbus_connection) {
  87                         plugin->hal_context = libhal_ctx_new();
  88                         if (plugin->hal_context) {
  89                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Got HAL context: %p", plugin->hal_context);
  90                                 if (libhal_ctx_set_dbus_connection(plugin->hal_context, dbus_g_connection_get_connection(plugin->dbus_connection))) {
  91                                         if (!libhal_ctx_set_user_data(plugin->hal_context, plugin)) {
  92                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't set user data of HAL context");
  93                                         }
  94                                         if (!libhal_ctx_set_device_condition(plugin->hal_context, mtetherd_hal_device_condition)) {
  95                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error assigning device condition callback");
  96                                         }
  97                                         if (!libhal_ctx_set_device_added(plugin->hal_context, mtetherd_hal_device_added)) {
  98                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error assigning device added callback");
  99                                         }
 100                                         if (!libhal_ctx_set_device_removed(plugin->hal_context, mtetherd_hal_device_removed)) {
 101                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error assigning device removed callback");
 102                                         }
 103                                         DBusError derr;
 104                                         dbus_error_init(&derr);
 105                                         if (!libhal_ctx_init(plugin->hal_context, &derr)) {
 106                                                 if (dbus_error_is_set(&derr)) {
 107                                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error initializing HAL context (%s): %s", derr.name, derr.message);
 108                                                         dbus_error_free(&derr);
 109                                                 } else {
 110                                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error initializing HAL context: unknown error");
 111                                                 }
 112                                                 libhal_ctx_free(plugin->hal_context);
 113                                                 plugin->hal_context = NULL;
 114                                                 return FALSE;
 115                                         }
 116                                 } else {
 117                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't set DBUS connection of HAL context");
 118                                         libhal_ctx_free(plugin->hal_context);
 119                                         plugin->hal_context = NULL;
 120                                         return FALSE;
 121                                 }
 122                         } else {
 123                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't allocate HAL context");
 124                                 return FALSE;
 125                         }
 126                 }
 127                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "HAL context initialized and connected");
 128                 return TRUE;
 129
 130         }
 131         return FALSE;
 132 }
 133
 134 void mtetherd_hal_finalize(MTetherDStatusPlugin *plugin) {
 135         if (plugin) {
 136                 if (plugin->hal_context) {
 137                         libhal_ctx_shutdown(plugin->hal_context, NULL);
 138                         libhal_ctx_free(plugin->hal_context);
 139                 }
 140                 if (plugin->dbus_connection) {
 141                         dbus_g_connection_unref(plugin->dbus_connection);
 142                 }
 143         }
 144 }
 145
 146 void mtetherd_hal_device_scan(MTetherDStatusPlugin *plugin) {
 147         if (plugin && plugin->hal_context) {
 148                 DBusError derr;
 149                 dbus_error_init(&derr);
 150                 int ndevices = 0;
 151                 char **udis = libhal_find_device_by_capability(plugin->hal_context, "net", &ndevices, &derr);
 152                 if (dbus_error_is_set(&derr)) {
 153                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error loading list of network devices (%s): %s", derr.name, derr.message);
 154                         dbus_error_free(&derr);
 155                 }
 156                 if (udis) {
 157                         int i;
 158                         for (i = 0; i < ndevices; i++) {
 159                                 char *interface = libhal_device_get_property_string(plugin->hal_context, udis[i], "net.interface", &derr);
 160                                 if (dbus_error_is_set(&derr)) {
 161                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error getting interface name of %s (%s): %s", udis[i], derr.name, derr.message);
 162                                         dbus_error_free(&derr);
 163                                 }
 164                                 if (interface) {
 165                                         MTetherDDevice *device = mtetherd_device_new(interface, udis[i]);
 166                                         if (device) {
 167                                                 mtetherd_status_plugin_device_added(plugin, device);
 168                                         }
 169                                         libhal_free_string(interface);
 170                                 }
 171                         }
 172                         libhal_free_string_array(udis);
 173                 }
 174         }
 175 }
 176
 177 gboolean mtetherd_usb_state(MTetherDStatusPlugin *plugin) {
 178         if (plugin) {
 179                 if (plugin->hal_context) {
 180                         DBusError derr;
 181                         dbus_error_init(&derr);
 182                         dbus_bool_t plugged = libhal_device_get_property_bool(plugin->hal_context, USBDEV_PATH, "button.state.value", &derr);
 183                         if (dbus_error_is_set(&derr)) {
 184                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error getting USB plugged status (%s): %s", derr.name, derr.message);
 185                                 //hildon_banner_show_informationf(GTK_WIDGET(plugin), NULL, "Error getting USB plugged status (%s): %s", derr.name, derr.message);
 186                                 dbus_error_free(&derr);
 187                         } else {
 188                                 return plugged;
 189                         }
 190                 }
 191         }
 192         return FALSE;
 193 }
 194
 195