hal.c

Go to the documentation of this file.

/*
 * File Name: hal.c
 */

/*
 * This file is part of sysd.
 *
 * sysd is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * sysd is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 *
 * Parts used from halevt, Copyright (C) 2007  Patrice Dumas <pertusus at free dot fr>
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

// system include files, between < >
#include <glib.h>
#include <hal/libhal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h> 
#include <errno.h>
#include <sys/statvfs.h>

// ereader include files, between < >
#include <liberipc/eripc.h>

// local include files, between " "
#include "log.h"
#include "conf.h"
#include "devicelist.h"
#include "hal.h"
#include "ipc.h"
#include "system.h"

#define UNUSED(x) (void)(x)


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------


//----------------------------------------------------------------------------
// Constants
//----------------------------------------------------------------------------

static const gchar *UDI_MMC_HOST = "/org/freedesktop/Hal/devices/platform_mxcmci_0_mmc_host";
static const gint SD_FREE_MB_ERROR_LEVEL  = 1;


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static LibHalContext *halContext        = NULL;
static gboolean g_unmount_all_volumes   = FALSE;
static gpointer g_unmount_callback_data = NULL;
static void (*g_unmount_callback_func)(gpointer user_data);

static gboolean g_remount_all_volumes   = FALSE;
static gpointer g_remount_callback_data = NULL;
static void (*g_remount_callback_func)(gpointer user_data);


//============================================================================
// Local Function Definitions
//============================================================================

static void hal_device_added            (LibHalContext *ctx, const char *udi);
static void hal_device_removed          (LibHalContext *ctx, const char *udi);
static void hal_device_property_modified(LibHalContext *ctx, const char *udi,
                                         const char *key, 
                                         dbus_bool_t is_removed, 
                                         dbus_bool_t is_added);
static int  hal_property_matches_udi    (const char *property, const char *value,
                                         const char *udi);
static char **hal_get_property_value    (LibHalPropertyType type, 
                                         const char *property, const char *udi, 
                                         DBusError *dbus_error_pointer);
static char **hal_udi_property_value    (const char *property, const char *udi);
//static char **hal_duplicate_str_list    (char** str_list);
//static int hal_property_matches_device(const char *key, const char *value, const hal_device *device);
static void volume_is_mounted           (LibHalContext *ctx, const char *udi);
static void remount_next_volume         (void);

static void unmount_volumes             (void);
static void unmount_volume              (hal_device *device);
static void unmount_volume_finished     (void);
static gboolean device_is_internal_mmc_host(hal_device *device);
static gboolean udi_is_internal_mmc_host(const char *udi);
static void udi_mount_volume            (const char *udi);


//============================================================================
// Functions Implementation
//============================================================================

gboolean hal_set_services()
{
    gboolean retval = FALSE;
    DBusConnection *dbus_connection;
    DBusError error;

    LOGPRINTF("entry");

    dbus_error_init (&error);

    halContext = libhal_ctx_new();
    if (halContext == NULL)
    {
        ERRORPRINTF("Failed to create HAL context");
        return FALSE;
    }
  
    dbus_connection = eripc_get_system_connection(eripcClient->context);
    
    retval = libhal_ctx_set_dbus_connection(halContext, dbus_connection);
    if (!retval)
    {
        ERRORPRINTF("Failed to setup dbus connection");
        return FALSE;
    }

    retval = libhal_ctx_set_device_added(halContext, hal_device_added);
    if (!retval)
    {
        ERRORPRINTF("Failed to set callback");
        return FALSE;
    }
    
    libhal_ctx_set_device_removed(halContext, hal_device_removed);
    libhal_ctx_set_device_property_modified(halContext, hal_device_property_modified);

    if (!libhal_ctx_init(halContext, NULL))
    {
        ERRORPRINTF("Failed to initialize HAL connection to daemon");
        libhal_ctx_free(halContext);
        halContext = NULL;
        return FALSE;
    }
    
    libhal_device_property_watch_all(halContext, &error);
    if (dbus_error_is_set (&error)) 
    {
        WARNPRINTF("Failed to watch all HAL properties: %s", error.message);
        dbus_error_free (&error);
        return FALSE;
    }
    
    return TRUE;
}


void hal_check_dbus_error(DBusError *error)
{
    if (dbus_error_is_set(error)) 
    {
        ERRORPRINTF("DBus Error! %s: %s", error->name, error->message);
        dbus_error_free(error);
    }
}


void hal_device_print(const char *udi)
{
    g_return_if_fail(halContext != NULL);
    
    libhal_device_print(halContext, udi, NULL);
}
       

void hal_add_devices()
{
    LOGPRINTF("entry");

    g_return_if_fail(halContext != NULL);
    
    DBusError error;
    char **all_udi = NULL;
    char **current_udi = NULL;
    int num_device = 0;
    hal_device *device = NULL;

    dbus_error_init(&error);
    all_udi = libhal_get_all_devices(halContext, &num_device, &error);
    hal_check_dbus_error(&error);

    if (all_udi == NULL)
    {
       LOGPRINTF("No HAL devices. Out of memory or an error occured in HAL");
       return;
    }

    current_udi = all_udi;

    while ((*current_udi) != NULL)
    {
        // Here we match all the removable devices that aren't 
        // already mounted and mount and register them.
        char *storage_device = libhal_device_get_property_string(halContext, *current_udi, "block.storage_device", NULL);
        if (  
               libhal_device_property_exists(halContext, *current_udi, "block.device", NULL)
               &&
               hal_property_matches_udi("block.is_volume", "true", *current_udi) 
               &&
               hal_property_matches_udi("volume.is_mounted", "false", *current_udi) 
           )
        {
            udi_mount_volume(*current_udi);
        }
        else if (
                   libhal_device_property_exists(halContext, *current_udi, "block.device", NULL)
                   &&
                   hal_property_matches_udi("block.is_volume", "true", *current_udi) 
                   &&
                   hal_property_matches_udi("volume.is_mounted", "true", *current_udi) 
                )
        {
            // register volumes already mounted at startup
            // this is mainly useful while testing
            volume_is_mounted(halContext, *current_udi);
        }
       
        device = hal_device_list_add_device(halContext, *current_udi);
        if (storage_device) libhal_free_string(storage_device);
        current_udi++;
    }
}


char **hal_get_iterator_value(const LibHalPropertyType type, LibHalPropertySetIterator *iter)
{
    char **value = NULL;
    char tmp[256];

    if (type == LIBHAL_PROPERTY_TYPE_STRLIST)
    {
       return libhal_psi_get_strlist(iter);
    }
 
    value = g_try_malloc0(2*sizeof(char *));
    if (value == NULL) 
    { 
        return NULL; 
    }
    value[1] = NULL;

    if (type == DBUS_TYPE_STRING)
    {
        char *hal_value = libhal_psi_get_string(iter);
        if (hal_value != NULL)
        {
            value[0] = g_strdup(hal_value);
        }
    }
    else if (type == DBUS_TYPE_BOOLEAN)
    {
        dbus_bool_t value_b = libhal_psi_get_bool(iter);
        if (value_b == TRUE)
        {
            value[0] = g_strdup("true");
        }
        else
        {
            value[0] = g_strdup("false");
        }
    }
    else if (type == DBUS_TYPE_INT32)
    {
        dbus_int32_t int_value = libhal_psi_get_int(iter);
        snprintf(tmp, 255, "%d", int_value);
        tmp[255] = '\0';
        value[0] = g_strdup(tmp);
    }
    else if (type == DBUS_TYPE_UINT64)
    {
        dbus_uint64_t uint_value = libhal_psi_get_uint64(iter);
        snprintf(tmp, 255, "%llu", uint_value);
        tmp[255] = '\0';
        value[0] = g_strdup(tmp);
    }
    else if (type == DBUS_TYPE_DOUBLE)
    {
        double dble_value = libhal_psi_get_double(iter);
        snprintf(tmp, 255, "%g", dble_value);
        tmp[255] = '\0';
        value[0] = g_strdup(tmp);
    }
    else
    {
        LOGPRINTF("Unhandled HAL iterator type: %d", type);
    }
    return value;
}


char **hal_property_value(const char *key, const char *udi, const hal_device* device)
{
    char **values;

    if ((udi == NULL) || (key == NULL))
    {
        LOGPRINTF("Warning: hal_property_value was called with a NULL value");
        return NULL;
    }
    if (!strcmp(key,"udi"))
    {
        char *new_udi = g_strdup(udi);
        if (new_udi == NULL) 
        { 
            return NULL; 
        }
        values = g_try_malloc0(2*sizeof(char*));
        if (values == NULL)
        {
            g_free(new_udi);
            return NULL;
        }
        values[0] = new_udi;
        values[1] = NULL;
        return values;
    }

    if (device != NULL) 
    { 
        hal_device_property *property = hal_device_list_get_property(key, device);
        return property->values;
    }
    return hal_udi_property_value(key, udi);
}


void hal_remount_all_volumes(gpointer callback_function, gpointer user_data)
{
    LOGPRINTF("entry");

    if (g_remount_callback_func != NULL)        
    {
        WARNPRINTF("sorry, remounting already in progress");
    }
    else
    {
        // setup callback function
        g_remount_all_volumes = TRUE;
        g_remount_callback_func = callback_function;
        g_remount_callback_data = user_data;
    
        // start remounting
        remount_next_volume();
    }
}


// deprecated
/*
void hal_report_mounted_volumes(const char *ipc_service)
{
    LOGPRINTF("entry");
    
    g_return_if_fail(ipc_service != NULL);
    
    hal_device *device = hal_device_list_get_root();
    hal_device_property *property;

    while (device != NULL)
    {
        property = hal_device_list_get_property("volume.is_mounted", device);
        if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
        {
            if (strcmp(*property->values, "true") == 0)
            {
                property = hal_device_list_get_property("volume.mount_point", device);
                if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
                {
                    LOGPRINTF("report volumeMounted %s to %s", *property->values, ipc_service);
                    ipc_send_volume_mounted_to(ipc_service, *property->values);
                }
            }
        }
        device = device->next;
    }
}
*/

void hal_unmount_all_volumes(gpointer callback_function, gpointer user_data)
{
    LOGPRINTF("entry");

    if (g_unmount_callback_func != NULL)        
    {
        WARNPRINTF("sorry, unmounting already in progress");
    }
    else
    {
        // setup callback function
        g_unmount_all_volumes = TRUE;
        g_unmount_callback_func = callback_function;
        g_unmount_callback_data = user_data;
    
        // flush buffers to disk
        sync();
        
        // start unmounting
        unmount_volumes();
    }
}


gchar *hal_get_mountpoint_device()
{
    LOGPRINTF("entry");

    gchar *dev_name = NULL;
    hal_device *device = hal_device_list_get_root();
    hal_device_property *property;

    while (device != NULL)
    {
        property = hal_device_list_get_property("volume.mount_point", device);
        if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
        {
            if ((*property->values !=NULL) && (strcmp(*property->values, MOUNTPOINT_CARD) == 0))
            {
                property = hal_device_list_get_property("block.device", device);
                if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
                {
                    dev_name = *property->values;
                    break;
                }
            }
        }
        device = device->next;
    }
    return dev_name;
}


//============================================================================
// Local Functions Implementation
//============================================================================

static void hal_device_added(LibHalContext *ctx, const char *udi)
{
    LOGPRINTF("entry: udi %s", udi);

    char *storage_device = libhal_device_get_property_string(ctx, udi, "block.storage_device", NULL);
    
    // This rule matches removable devices which have volume.policy.should_mount true
    // or don't have volume.policy.should_mount false.
    // Upon insertion, they are mounted and recorded.
    if ( libhal_device_property_exists(ctx, udi, "block.device", NULL)
         &&
         hal_property_matches_udi("block.is_volume", "true", udi) )
    {
        udi_mount_volume(udi);
    }     
    
    // sync the devices list
    hal_device_list_add_device(ctx, udi);
    
    if (storage_device) libhal_free_string(storage_device);
}


static void hal_device_removed(LibHalContext *ctx, const char *udi)
{
    UNUSED(ctx);
    LOGPRINTF("entry: udi %s", udi);

    // use the device from the devices list since the 
    // properties will be right 
    hal_device *removed_device = NULL;
    removed_device = hal_device_list_find_device(udi);
    if (removed_device != NULL)
    {
        // When a device is removed, it is recorded.
        // Note that at that point the device is already out of hal, so we use
        // cannot match or get properties
        
        enum state_card state = sys_get_card();
        if (state != STATE_CARD_EJECTED)
        {
            if (device_is_internal_mmc_host(removed_device))
            {            
                if (state == STATE_CARD_MOUNTED)
                {
                    WARNPRINTF("card ejected before unmount, force unmount now");
                    
                    // force lazy unmount
                    sys_spawn_async("umount -lf " MOUNTPOINT_CARD);
                    
                    // report to applications
                    ipc_send_volume_unmounted(MOUNTPOINT_CARD);
                    
                    sys_set_card(STATE_CARD_UNMOUNTED);
                }
                else 
                {
                    sys_set_card(STATE_CARD_EJECTED);
                }
            }
        }
        
        // sync the devices list 
        hal_device_list_remove_device(udi);
    }
    else
    {
        WARNPRINTF("Cannot find device %s in hal list", udi);
        
        // FIXME resync devices list? 
        // FIXME try to run checks and commands on removed devices anyway
    }    
}


static gboolean udi_is_internal_mmc_host(const char *udi)
{
    char *ip  = NULL;
    ip = libhal_device_get_property_string(halContext, udi, "info.parent", NULL);
    if (ip)
    {
        // on coldplug, the parent's parent is the mmc host as we don't appear to have the card device itself
        // this may be a HAL issue but we accept this for now
        if (hal_property_matches_udi("info.parent", UDI_MMC_HOST, ip))
        {
            libhal_free_string(ip);
            return TRUE;
        }
        else
        {
            char *ipp  = NULL;
            ipp = libhal_device_get_property_string(halContext, ip, "info.parent", NULL);
            libhal_free_string(ip);
            if (ipp)
            {
                // on hotplug, the parent's parent's parent is the mmc host as one would expect
                if (hal_property_matches_udi("info.parent", UDI_MMC_HOST, ipp))
                {
                    libhal_free_string(ipp);
                    return TRUE;
                }
            }
        }
    }
    return FALSE;
}


static void udi_mount_volume(const char *udi)
{
    LOGPRINTF("entry udi [%s]", udi);
    
    char *command = NULL;

    if (udi_is_internal_mmc_host(udi))
    {
        // remove mountpoint just it case it still exists which causes mount to fail
        gint retval = rmdir(MOUNTPOINT_CARD);
        if ((retval == 0) || (errno == ENOENT))
        {
            // set mountpoint for internal MMC card
            char *dev_name = g_path_get_basename(MOUNTPOINT_CARD);
            command = g_strdup_printf("halevt-mount -u %s -p %s -m 002 -o %s", udi, dev_name, MOUNT_OPTIONS);
            g_free(dev_name);
        }
        else
        {
            ERRORPRINTF("mounting failed, %s is already occupied (%d, %s)", MOUNTPOINT_CARD, errno, strerror(errno));
        }                    
    }
    else
    {
        // default mountpoint is the volume label
        command = g_strdup_printf("halevt-mount -u %s -m 002 -o %s", udi, MOUNT_OPTIONS);
    }
        
    if (command)
    {
        sys_reset_idle_time();
        sys_spawn_async(command);
        g_free(command);
    }
}


static gboolean device_is_internal_mmc_host(hal_device *device)
{
    LOGPRINTF("entry");
    hal_device_property *property = NULL;
    
    property = hal_device_list_get_property("info.parent", device);
    if (property  && (*property->values != NULL)) 
    {
        // on coldplug, the parent's parent is the mmc host as we don't appear to have the card device itself
        // this may be a HAL issue but we accept this for now
        property = hal_device_list_get_property("info.parent", hal_device_list_find_device(*property->values));
        if (property && (*property->values != NULL) && (strcmp(*property->values, UDI_MMC_HOST) == 0))
        {
            return TRUE;
        }
        else 
        {
            // on hotplug, the parent's parent's parent is the mmc host as one would expect
            property = hal_device_list_get_property("info.parent", hal_device_list_find_device(*property->values));
            if (property && (*property->values != NULL) && (strcmp(*property->values, UDI_MMC_HOST) == 0))
            {
                return TRUE;
            }
        }
    }
    return FALSE;
}


static void hal_device_property_modified(LibHalContext *ctx, const char *udi,
                                         const char *key, dbus_bool_t is_removed, dbus_bool_t is_added)
{
    UNUSED(is_added);
    LOGPRINTF("entry: udi %s, key %s, added:%d, removed:%d", udi, key, is_added, is_removed);

    g_return_if_fail(key!=NULL);
    
    if (strcmp(key,"volume.mount_point") == 0)
    { 
        char *mount_point = libhal_device_get_property_string(ctx, udi, "volume.mount_point", NULL);
        
        LOGPRINTF("volume.mount_point = %s", mount_point);
        
        if ((mount_point != NULL) && (mount_point[0] != '\0'))
        {
            LOGPRINTF("Filled volume.mount_point, wait for is_mounted callback");
            // mount point created, wait for is_mounted callback
        }
        else
        {
            LOGPRINTF("Cleared volume.mount_point, find in device list");

            // mount point removed, handle here because
            // in the is_mounted callback we don't know the mount point anymore
            
            hal_device *removed_device = NULL;
            hal_device_property *property = NULL;
            
            removed_device = hal_device_list_find_device(udi);
            
            if (removed_device != NULL)
            {
                property = hal_device_list_get_property("volume.mount_point", removed_device);
                if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
                {
                    LOGPRINTF("Mountpoint removed [%s]", *property->values);

                    sys_reset_idle_time();

                    // update mount information 
                    sys_spawn_async("halevt-mount -s");
                    
                    // report to applications
                    ipc_send_volume_unmounted(*property->values);
                    
                    if (strcmp(*property->values, MOUNTPOINT_CARD) == 0)
                    {
                        sys_set_card(STATE_CARD_UNMOUNTED);
                    }

                    // remove from device list before continuing with next volume
                    hal_device_list_remove_property(udi, key);               
                }
            }
            else
            {
                WARNPRINTF("mount point for %s not found", key);
            }
        }
        if (mount_point) libhal_free_string(mount_point);
    }
    else if (strcmp(key,"volume.is_mounted") == 0)
    {
        // When a device get a mount point, it is recorded.
        // When a device is unmounted, it is recorded.
        LOGPRINTF("volume.is_mounted");
        
        // DEBUG ONLY -- STRING SHOULD BE FREED
/*
        LOGPRINTF("A: %d", libhal_device_property_exists(ctx, udi, "block.device", NULL));
        LOGPRINTF("B: %d", libhal_device_get_property_bool(ctx, udi, "block.is_volume", NULL));
        LOGPRINTF("C: %d", libhal_device_property_exists(ctx, udi, "volume.mount_point", NULL));
*/        
        if ( libhal_device_property_exists(ctx, udi, "block.device", NULL)
             &&
             libhal_device_get_property_bool(ctx, udi, "block.is_volume", NULL) ) 
        {
            // update mount information 
            sys_spawn_async("halevt-mount -s");

            if (libhal_device_get_property_bool(ctx, udi, "volume.is_mounted", NULL))
            {
                // update before remounting next volume
                hal_device_list_set_property(udi, key);

                volume_is_mounted(ctx, udi);
            }
            else
            {
                // unmount handled at mount_point as we don't know the mount point when we're here
            } 
        }
    }
    else if (strcmp(key,"irex.battery") == 0)
    {
        LOGPRINTF("irex.battery");
        
        char *battery = libhal_device_get_property_string(ctx, udi, "irex.battery", NULL);
        if (battery) 
        {
            sys_update_battery(battery);
            libhal_free_string(battery);
        }
    }
    else if (strcmp(key,"irex.hardware_state") == 0)
    {
        LOGPRINTF("irex.hardware_state");
        
        char *hw_sate = libhal_device_get_property_string(ctx, udi, "irex.hardware_state", NULL);
        if (hw_sate) 
        {
            sys_update_hardware(hw_sate);
            libhal_free_string(hw_sate);
        }
    }

    // now sync the properties in the devices list
    if (is_removed)
    {
        hal_device_list_remove_property(udi, key);
    }
    else
    {
        hal_device_list_set_property(udi, key);
    }
}


static char **hal_get_property_value(LibHalPropertyType type, const char *property, const char *udi, 
                                     DBusError *dbus_error_pointer)
{
    char **value = NULL;
    char tmp[256];

    if (type == LIBHAL_PROPERTY_TYPE_STRLIST)
    {
       return libhal_device_get_property_strlist(halContext, udi, property, dbus_error_pointer);;
    }
 
    value = g_try_malloc0(2*sizeof(char *));
    if (value == NULL) 
    { 
        return NULL; 
    }
    value[1] = NULL;

    if (type == DBUS_TYPE_STRING)
    {
        char *hal_value = libhal_device_get_property_string(halContext, udi, property, dbus_error_pointer);
        if (hal_value != NULL)
        {
            value[0] = g_strdup(hal_value);
            libhal_free_string(hal_value);
        }
    }
    else if (type == DBUS_TYPE_BOOLEAN)
    {
        dbus_bool_t value_b = libhal_device_get_property_bool(halContext, udi, property, dbus_error_pointer);
        if (value_b == TRUE)
        {
            value[0] = g_strdup("true");
        }
        else
        {
            value[0] = g_strdup("false");
        }
    }
    else if (type == DBUS_TYPE_INT32)
    {
        dbus_int32_t int_value = libhal_device_get_property_int(halContext, udi, property, dbus_error_pointer);
        snprintf(tmp, 255, "%d", int_value);
        tmp[255] = '\0';
        value[0] = g_strdup(tmp);
    }
    else if (type == DBUS_TYPE_UINT64)
    {
        dbus_uint64_t uint_value = libhal_device_get_property_uint64(halContext, udi, property, dbus_error_pointer);
        snprintf(tmp, 255, "%llu", uint_value);
        tmp[255] = '\0';
        value[0] = g_strdup(tmp);
    }
    else if (type == DBUS_TYPE_DOUBLE)
    {
        double dble_value = libhal_device_get_property_double(halContext, udi, property, dbus_error_pointer);
        snprintf(tmp, 255, "%g", dble_value);
        tmp[255] = '\0';
        value[0] = g_strdup(tmp);
    }
    else
    {
        LOGPRINTF("Unhandled HAL type for property %s, device %s: %d", property, udi, type);
    }
    return value;
}


static int hal_property_matches_udi(const char *property, const char *value, const char *udi)
{
   DBusError dbus_error;
   int result = 0;
    
   if ((udi == NULL) || (property == NULL) || (value == NULL))
   {
      LOGPRINTF("Warning: hal_property_matches called with a NULL value");
      return 0;
   }

   dbus_error_init(&dbus_error);

//   LOGPRINTF("match %s, %s, %s", property, value, udi);
    
   if (libhal_device_property_exists(halContext, udi, property, &dbus_error))
   {
      LibHalPropertyType type;
       
//      LOGPRINTF("property exists %s", property);

      hal_check_dbus_error(&dbus_error);

      if (value == NULL) 
      { 
           return 1; 
      }

      type = libhal_device_get_property_type(halContext, udi, property, &dbus_error);
      hal_check_dbus_error(&dbus_error);
       
//      LOGPRINTF("property type %d", type);

      if (type == DBUS_TYPE_BOOLEAN)
      {
          dbus_bool_t val_bool = FALSE;
          if (!strcmp(value, "true")) 
          { 
              val_bool = TRUE; 
          }
          result = (libhal_device_get_property_bool(halContext, udi, property, &dbus_error) == val_bool);
      }
      else if (type == DBUS_TYPE_STRING)
      {
          char *str_val = libhal_device_get_property_string(halContext, udi, property, &dbus_error);
          if (str_val != NULL)
          {
             result = (!strcmp(value, str_val));
             libhal_free_string(str_val);
          }
      }
      else if (type == DBUS_TYPE_INT32)
      {
          result = (libhal_device_get_property_int(halContext, udi, property, &dbus_error) == atoi(value));
      } /* FIXME: LIBHAL_PROPERTY_TYPE_STRLIST */
      else if (type == LIBHAL_PROPERTY_TYPE_STRING)
      {
          char **cur_str;
          char **str_list = libhal_device_get_property_strlist(halContext, udi, property, &dbus_error);
          if (str_list != NULL)
          {
              cur_str = str_list;
              while ((*cur_str) != NULL)
              {
                  if (!strcmp((*cur_str), value))
                  {
                      result = 1;
                      break;
                  }
                  cur_str++;
              }
              libhal_free_string_array(str_list);
          }
      }
      else if (type == DBUS_TYPE_UINT64)
      {
          result = ( (guint64) libhal_device_get_property_int(halContext, udi, property, &dbus_error) == 
                  strtoull(value, NULL, 10) );
      }
      else if (type == DBUS_TYPE_DOUBLE)
      {
          result = (libhal_device_get_property_double(halContext, udi, property, &dbus_error) == 
                  strtod(value, NULL));
      }
      else
      {
         LOGPRINTF("HAL type not handled in match (%s,%s,%s): %d", property, value, udi, type);
         return 0;
      }
   }

   hal_check_dbus_error(&dbus_error);

   return result;
}


static char **hal_udi_property_value(const char *property, const char *udi)
{
    char **values = NULL;
    DBusError dbus_error;

    if ((udi == NULL) || (property == NULL))
    {
        WARNPRINTF("hal_udi_property_value was called with a NULL value");
        return NULL;
    }

    dbus_error_init(&dbus_error);

    if (libhal_device_property_exists(halContext, udi, property, &dbus_error))
    {
        LibHalPropertyType type;

        hal_check_dbus_error(&dbus_error);

        type = libhal_device_get_property_type(halContext, udi, property, &dbus_error);
        hal_check_dbus_error(&dbus_error);

        values = hal_get_property_value(type, property, udi, &dbus_error);
    }
    hal_check_dbus_error(&dbus_error);

    return values;
}

/*
static char **hal_duplicate_str_list(char** str_list)
{
   char **value = NULL;
   char **cur_str;

   if (str_list != NULL)
   {
       char *cur_val;
       unsigned int total_value_nr;
       char **cur_value;
       total_value_nr = libhal_string_array_length(str_list);       

       value = g_try_malloc0((total_value_nr+1) * sizeof(char*));
       if (value == NULL)
       { 
           libhal_free_string_array(str_list);
           return NULL;
       }
       *value = NULL;

       cur_str = str_list;
       cur_value = value;
              
       while ((*cur_str) != NULL)
       {
           cur_val = g_strdup(*cur_str);
           if (cur_val == NULL)
           { 
               libhal_free_string_array (str_list);
               cur_value = value;
               while ((*cur_value) != NULL)
               {
                   g_free(*cur_value);
                   cur_value++;
               }
               g_free(value);
               return NULL;
           }
           *cur_value = cur_val;
           cur_value++;
           *cur_value = NULL;
           cur_str++;
       }
       libhal_free_string_array(str_list);
   }
   return value;
}
*/

static void volume_is_mounted(LibHalContext *ctx, const char *udi)
{
    // report mount to applications
    char *mount_point = libhal_device_get_property_string(ctx, udi, "volume.mount_point", NULL);
    
    LOGPRINTF("entry udi [%s] mount_point [%s]", udi, mount_point);
    
    if (mount_point)
    {
        sys_reset_idle_time();
        
        // check available free space
        gint64     mbfree   = -1;
        gboolean  readonly = FALSE;
        gboolean  sdfull   = FALSE;
        
        struct statvfs s;
        if (statvfs(mount_point, &s) == 0) 
        {
            mbfree   = s.f_frsize * s.f_bavail >> 20;
            if (s.f_flag & ST_RDONLY)
            {
                readonly = TRUE;
            }
        }

        LOGPRINTF("mbfree [%lld] readonly [%d]", mbfree, readonly);
        
        if (mbfree == -1)
        {
            ERRORPRINTF("failed to get free space from mount point [%s]", mount_point);
        }
        else if (readonly)
        {
            ipc_show_splash("sdreadonly");
        }
        else if (mbfree <= SD_FREE_MB_ERROR_LEVEL)
        {
            ipc_show_splash("sdfull");
            sdfull = TRUE;
        }
        
        if (!readonly)
        { 
            // continue mounting volume
            //
            if (sys_is_emulator())
            {
                LOGPRINTF("EMULATOR Emulate mount at [%s]", MOUNTPOINT_CARD);
                sys_set_card(STATE_CARD_INDEXING);
            }
            else
            {
                if (strcmp(mount_point, MOUNTPOINT_CARD) == 0)
                {
                    LOGPRINTF("Internal card found at [%s]", MOUNTPOINT_CARD);
                    if (sdfull)
                    {
                        // mount so it can be exported to USB but skip indexing
                        sys_set_card(STATE_CARD_MOUNTED);
                    }
                    else
                    {
                        sys_set_card(STATE_CARD_INDEXING);
                    }
                }
                else
                {
                    LOGPRINTF("Volume found at [%s]", mount_point);
                    ipc_send_volume_mounted(mount_point);
                }
            }
        }
        else
        {
            if (strcmp(mount_point, MOUNTPOINT_CARD) == 0)
            {
                sys_set_card(STATE_CARD_INACCESSIBLE);
            }
            
            // unmount volume
            //
            hal_device *device = hal_device_list_find_device(udi);
            unmount_volume(device);
        }

        libhal_free_string(mount_point);
    }
    
    if (g_remount_all_volumes)
    {
        // look for next volume to remount
        remount_next_volume();
    }
}


static void unmount_volumes()
{
    LOGPRINTF("entry");
    
    hal_device *device = hal_device_list_get_root();
    if (device != NULL)
    {
        unmount_volume(device);
    }
    else
    {
        LOGPRINTF("no volumes to unmount");
        unmount_volume_finished();
    }
}


static void on_volume_unmounted(GPid pid, gint status, gpointer data)
{
    UNUSED(pid);
    UNUSED(status);
    LOGPRINTF("entry");
    
    hal_device *device = (hal_device *) data;
    if (device->next && g_unmount_all_volumes) 
    {
        // unmount next volume
        unmount_volume(device->next);
    }
    else
    {
        LOGPRINTF("no more volumes to unmount");
        unmount_volume_finished();
    }
}


static void unmount_volume_finished(void)
{
    LOGPRINTF("entry");
    
    // unmounting finished, execute callback handler
    if (g_unmount_callback_func)
    {
        LOGPRINTF("call callback handler");

        (*g_unmount_callback_func)(g_unmount_callback_data);

        // reset
        g_unmount_callback_func = NULL;
        g_unmount_callback_data = NULL;
    }
    else
    {
        LOGPRINTF("no callback handler");
    }
}


static void unmount_volume(hal_device *device)
{
    LOGPRINTF("entry");
    
    while (device != NULL)
    {
        hal_device_property *property = NULL;
        property = hal_device_list_get_property("volume.is_mounted", device);
        if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
        {
            LOGPRINTF("udi %s, volume.is_mounted = %s", device->udi, *property->values);
            if (strcmp(*property->values, "true") == 0)
            {
                property = hal_device_list_get_property("volume.mount_point", device);
                if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
                {
                    gchar *command = NULL;
                    command = g_strconcat("unmount.sh ", *property->values, NULL);
                    LOGPRINTF("%s", command);
                    // late recurse
                    sys_spawn_async_with_callback(command, on_volume_unmounted, device);
                    g_free(command);
                    return;
                }
            }
        }
        device = device->next;
    }
    
    LOGPRINTF("no more volumes to unmount");
    unmount_volume_finished();
}


static void remount_next_volume()
{
    LOGPRINTF("entry");
    
    hal_device *device = hal_device_list_get_root();
    hal_device_property *property = NULL;

    while (device != NULL)
    {
        property = hal_device_list_get_property("volume.is_mounted", device);
        if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
        {
            LOGPRINTF("udi %s, volume.is_mounted = %s", device->udi, *property->values);
            if (strcmp(*property->values, "false") == 0)
            {
                udi_mount_volume(device->udi);
                return;
            }
        }
        device = device->next;
    }
    
    // no unmounted volume found, stop trying
    LOGPRINTF("no more volume to remmount");
    g_remount_all_volumes = FALSE;
    
    // execute callback handler
    if (g_remount_callback_func)
    {
        LOGPRINTF("call callback handler");

        (*g_remount_callback_func)(g_remount_callback_data);

        // reset
        g_remount_callback_func = NULL;
        g_remount_callback_data = NULL;
    }
    else
    {
        LOGPRINTF("no callback handler");
    }        
}