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_MESSAGE, "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_MESSAGE, "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_MESSAGE, "Got HAL device added 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_MESSAGE, "Got DBUS Glib connection: %p", plugin->dbus_connection);
  85                 }
  86                 if (plugin->dbus_connection) {
  87                         plugin->hal_context = libhal_ctx_new();
  88                         if (plugin->hal_context) {
  89                                 if (libhal_ctx_set_dbus_connection(plugin->hal_context, dbus_g_connection_get_connection(plugin->dbus_connection))) {
  90                                         if (!libhal_ctx_set_user_data(plugin->hal_context, plugin)) {
  91                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't set user data of HAL context");
  92                                         }
  93                                         if (!libhal_ctx_set_device_condition(plugin->hal_context, mtetherd_hal_device_condition)) {
  94                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error assigning device condition callback");
  95                                         }
  96                                         if (!libhal_ctx_set_device_added(plugin->hal_context, mtetherd_hal_device_added)) {
  97                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error assigning device added callback");
  98                                         }
  99                                         if (!libhal_ctx_set_device_removed(plugin->hal_context, mtetherd_hal_device_removed)) {
 100                                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error assigning device removed callback");
 101                                         }
 102                                         DBusError derr;
 103                                         dbus_error_init(&derr);
 104                                         if (!libhal_ctx_init(plugin->hal_context, &derr)) {
 105                                                 if (dbus_error_is_set(&derr)) {
 106                                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error initializing HAL context (%s): %s", derr.name, derr.message);
 107                                                         dbus_error_free(&derr);
 108                                                 } else {
 109                                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error initializing HAL context: unknown error");
 110                                                 }
 111                                                 libhal_ctx_free(plugin->hal_context);
 112                                                 plugin->hal_context = NULL;
 113                                                 return FALSE;
 114                                         }
 115                                 } else {
 116                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't set DBUS connection of HAL context");
 117                                         libhal_ctx_free(plugin->hal_context);
 118                                         plugin->hal_context = NULL;
 119                                         return FALSE;
 120                                 }
 121                         } else {
 122                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Can't allocate HAL context");
 123                                 return FALSE;
 124                         }
 125                 }
 126                 return TRUE;
 127
 128         }
 129         return FALSE;
 130 }
 131
 132 void mtetherd_hal_finalize(MTetherDStatusPlugin *plugin) {
 133         if (plugin) {
 134                 if (plugin->hal_context) {
 135                         libhal_ctx_shutdown(plugin->hal_context, NULL);
 136                         libhal_ctx_free(plugin->hal_context);
 137                 }
 138                 if (plugin->dbus_connection) {
 139                         dbus_g_connection_unref(plugin->dbus_connection);
 140                 }
 141         }
 142 }
 143
 144 void mtetherd_hal_device_scan(MTetherDStatusPlugin *plugin) {
 145         if (plugin && plugin->hal_context) {
 146                 DBusError derr;
 147                 dbus_error_init(&derr);
 148                 int ndevices = 0;
 149                 char **udis = libhal_find_device_by_capability(plugin->hal_context, "net", &ndevices, &derr);
 150                 if (dbus_error_is_set(&derr)) {
 151                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error loading list of network devices (%s): %s", derr.name, derr.message);
 152                         dbus_error_free(&derr);
 153                 }
 154                 if (udis) {
 155                         int i;
 156                         for (i = 0; i < ndevices; i++) {
 157                                 char *interface = libhal_device_get_property_string(plugin->hal_context, udis[i], "net.interface", &derr);
 158                                 if (dbus_error_is_set(&derr)) {
 159                                         g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error getting interface name of %s (%s): %s", udis[i], derr.name, derr.message);
 160                                         dbus_error_free(&derr);
 161                                 }
 162                                 if (interface) {
 163                                         MTetherDDevice *device = mtetherd_device_new(interface, udis[i]);
 164                                         if (device) {
 165                                                 mtetherd_status_plugin_device_added(plugin, device);
 166                                         }
 167                                         libhal_free_string(interface);
 168                                 }
 169                         }
 170                         libhal_free_string_array(udis);
 171                 }
 172         }
 173 }
 174
 175 gboolean mtetherd_usb_state(MTetherDStatusPlugin *plugin) {
 176         if (plugin) {
 177                 if (plugin->hal_context) {
 178                         DBusError derr;
 179                         dbus_error_init(&derr);
 180                         dbus_bool_t plugged = libhal_device_get_property_bool(plugin->hal_context, USBDEV_PATH, "button.state.value", &derr);
 181                         if (dbus_error_is_set(&derr)) {
 182                                 g_log(MTETHERD_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Error getting USB plugged status (%s): %s", derr.name, derr.message);
 183                                 //hildon_banner_show_informationf(GTK_WIDGET(plugin), NULL, "Error getting USB plugged status (%s): %s", derr.name, derr.message);
 184                                 dbus_error_free(&derr);
 185                         } else {
 186                                 return plugged;
 187                         }
 188                 }
 189         }
 190         return FALSE;
 191 }
 192
 193