hal.c File Reference

#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>
#include <liberipc/eripc.h>
#include "log.h"
#include "conf.h"
#include "devicelist.h"
#include "hal.h"
#include "ipc.h"
#include "system.h"

Include dependency graph for hal.c:

Go to the source code of this file.

Defines
#define	UNUSED(x)   (void)(x)
Functions
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 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)
gboolean	hal_set_services ()
	Setup HAL context and set callbacks for hal events.
void	hal_check_dbus_error (DBusError *error)
	Print and reset a dbus error.
void	hal_device_print (const char *udi)
	Print a device to stdout, useful for debugging.
void	hal_add_devices ()
	Scan HAL for available devices, run init and add to devicelist.
char **	hal_get_iterator_value (const LibHalPropertyType type, LibHalPropertySetIterator *iter)
	Return the value of iterator from Hal properties.
char **	hal_property_value (const char *key, const char *udi, const hal_device *device)
	Return the value of Hal property.
void	hal_remount_all_volumes (gpointer callback_function, gpointer user_data)
void	hal_unmount_all_volumes (gpointer callback_function, gpointer user_data)
gchar *	hal_get_mountpoint_device ()
static void	on_volume_unmounted (GPid pid, gint status, gpointer data)
Variables
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 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)

---

Define Documentation

#define UNUSED

(

x

)

(void)(x)

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Parts used from halevt, Copyright (C) 2007 Patrice Dumas <pertusus at="" free="" dot="" fr>="">

Definition at line 54 of file hal.c.

---

Function Documentation

static gboolean device_is_internal_mmc_host

(

hal_device *

device

)

[static]

Definition at line 606 of file hal.c.

References hal_device_list_find_device(), hal_device_list_get_property(), LOGPRINTF, and UDI_MMC_HOST.

Referenced by hal_device_removed().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_add_devices

(

void

)

Scan HAL for available devices, run init and add to devicelist.

---------------------------------------------------------------------------

Name : hal_add_devices

Parameters:

--

Returns:

--

--------------------------------------------------------------------------

Definition at line 191 of file hal.c.

References hal_check_dbus_error(), hal_device_list_add_device(), hal_property_matches_udi(), halContext, LOGPRINTF, udi_mount_volume(), and volume_is_mounted().

Referenced by start_phase_3().

{
    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++;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_check_dbus_error

(

DBusError *

error

)

Print and reset a dbus error.

---------------------------------------------------------------------------

Name : hal_check_dbus_error

Parameters:

error

Pointer to DBusError, memory is freed when set

Returns:

--

--------------------------------------------------------------------------

Definition at line 173 of file hal.c.

References ERRORPRINTF.

Referenced by hal_add_devices(), hal_device_list_add_device(), hal_property_matches_udi(), and hal_udi_property_value().

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

Here is the caller graph for this function:

static void hal_device_added	(	LibHalContext *	ctx,
		const char *	udi
	)			[static]

Definition at line 461 of file hal.c.

References hal_device_list_add_device(), hal_property_matches_udi(), LOGPRINTF, and udi_mount_volume().

Referenced by hal_set_services().

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_device_print

(

const char *

udi

)

Print a device to stdout, useful for debugging.

---------------------------------------------------------------------------

Name : hal_device_print

Parameters:

udi

Unique Device Id

Returns:

--

--------------------------------------------------------------------------

Definition at line 183 of file hal.c.

References halContext.

Referenced by hal_print_all_devices().

{
    g_return_if_fail(halContext != NULL);
    
    libhal_device_print(halContext, udi, NULL);
}

Here is the caller graph for this function:

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]

Definition at line 635 of file hal.c.

References hal_device_list_find_device(), hal_device_list_get_property(), hal_device_list_remove_property(), hal_device_list_set_property(), ipc_send_volume_unmounted(), LOGPRINTF, MOUNTPOINT_CARD, STATE_CARD_UNMOUNTED, sys_reset_idle_time(), sys_set_card(), sys_spawn_async(), sys_update_battery(), sys_update_hardware(), UNUSED, volume_is_mounted(), and WARNPRINTF.

Referenced by hal_set_services().

{
    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);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void hal_device_removed	(	LibHalContext *	ctx,
		const char *	udi
	)			[static]

Definition at line 484 of file hal.c.

References device_is_internal_mmc_host(), hal_device_list_find_device(), hal_device_list_remove_device(), ipc_send_volume_unmounted(), LOGPRINTF, MOUNTPOINT_CARD, STATE_CARD_EJECTED, STATE_CARD_MOUNTED, STATE_CARD_UNMOUNTED, sys_get_card(), sys_set_card(), sys_spawn_async(), UNUSED, and WARNPRINTF.

Referenced by hal_set_services().

{
    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
    }    
}

Here is the call graph for this function:

Here is the caller graph for this function:

char** hal_get_iterator_value	(	const LibHalPropertyType	type,
		LibHalPropertySetIterator *	iter
	)

Return the value of iterator from Hal properties.

---------------------------------------------------------------------------

Name : hal_get_iterator_value

Parameters:

	type	LibHalPropertyType type of property
	iter	LibHalPropertySetIterator iterator

Returns:

value array

--------------------------------------------------------------------------

Definition at line 250 of file hal.c.

References LOGPRINTF.

Referenced by hal_device_list_add_device().

{
    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;
}

Here is the caller graph for this function:

gchar* hal_get_mountpoint_device

(

void

)

Definition at line 428 of file hal.c.

References hal_device_list_get_property(), hal_device_list_get_root(), LOGPRINTF, MOUNTPOINT_CARD, hal_device::next, and hal_device_property::values.

Referenced by sys_set_card().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char ** hal_get_property_value	(	LibHalPropertyType	type,
		const char *	property,
		const char *	udi,
		DBusError *	dbus_error_pointer
	)			[static]

Definition at line 764 of file hal.c.

References halContext, and LOGPRINTF.

Referenced by hal_udi_property_value().

{
    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;
}

Here is the caller graph for this function:

static int hal_property_matches_udi	(	const char *	property,
		const char *	value,
		const char *	udi
	)			[static]

Definition at line 832 of file hal.c.

References hal_check_dbus_error(), halContext, and LOGPRINTF.

Referenced by hal_add_devices(), hal_device_added(), and udi_is_internal_mmc_host().

{
   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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char** hal_property_value	(	const char *	key,
		const char *	udi,
		const hal_device *	device
	)

Return the value of Hal property.

---------------------------------------------------------------------------

Name : hal_property_value

Parameters:

	key
	udi	Unique Device Id
	device	hal_device

Returns:

value array

--------------------------------------------------------------------------

Definition at line 316 of file hal.c.

References hal_device_list_get_property(), hal_udi_property_value(), and LOGPRINTF.

Referenced by hal_device_list_set_property().

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_remount_all_volumes	(	gpointer	callback_function,
		gpointer	user_data
	)

Definition at line 352 of file hal.c.

References g_remount_all_volumes, g_remount_callback_data, g_remount_callback_func, LOGPRINTF, remount_next_volume(), and WARNPRINTF.

Referenced by cb_sys_card_mount(), and usb_set_state().

{
    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();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean hal_set_services

(

void

)

Setup HAL context and set callbacks for hal events.

---------------------------------------------------------------------------

Name : hal_set_services

Parameters:

--

Returns:

TRUE if successfully set up, FALSE otherwise

--------------------------------------------------------------------------

Definition at line 117 of file hal.c.

References eripc_client_context_t::context, eripc_get_system_connection(), eripcClient, ERRORPRINTF, hal_device_added(), hal_device_property_modified(), hal_device_removed(), halContext, LOGPRINTF, and WARNPRINTF.

Referenced by main().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char ** hal_udi_property_value	(	const char *	property,
		const char *	udi
	)			[static]

Definition at line 929 of file hal.c.

References hal_check_dbus_error(), hal_get_property_value(), halContext, and WARNPRINTF.

Referenced by hal_property_value().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_unmount_all_volumes	(	gpointer	callback_function,
		gpointer	user_data
	)

Definition at line 404 of file hal.c.

References g_unmount_all_volumes, g_unmount_callback_data, g_unmount_callback_func, LOGPRINTF, sync(), unmount_volumes(), and WARNPRINTF.

Referenced by do_unmount().

{
    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();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void on_volume_unmounted	(	GPid	pid,
		gint	status,
		gpointer	data
	)			[static]

Definition at line 1122 of file hal.c.

References g_unmount_all_volumes, LOGPRINTF, hal_device::next, unmount_volume(), unmount_volume_finished(), and UNUSED.

Referenced by unmount_volume().

{
    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();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void remount_next_volume

(

void

)

[static]

Definition at line 1198 of file hal.c.

References g_remount_all_volumes, g_remount_callback_data, g_remount_callback_func, hal_device_list_get_property(), hal_device_list_get_root(), LOGPRINTF, hal_device::next, hal_device::udi, and udi_mount_volume().

Referenced by hal_remount_all_volumes(), and volume_is_mounted().

{
    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");
    }        
}

Here is the call graph for this function:

Here is the caller graph for this function:

static gboolean udi_is_internal_mmc_host

(

const char *

udi

)

[static]

Definition at line 536 of file hal.c.

References hal_property_matches_udi(), halContext, and UDI_MMC_HOST.

Referenced by udi_mount_volume().

{
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void udi_mount_volume

(

const char *

udi

)

[static]

Definition at line 569 of file hal.c.

References ERRORPRINTF, LOGPRINTF, MOUNT_OPTIONS, MOUNTPOINT_CARD, sys_reset_idle_time(), sys_spawn_async(), and udi_is_internal_mmc_host().

Referenced by hal_add_devices(), hal_device_added(), and remount_next_volume().

{
    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);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unmount_volume

(

hal_device *

device

)

[static]

Definition at line 1164 of file hal.c.

References hal_device_list_get_property(), LOGPRINTF, hal_device::next, on_volume_unmounted(), sys_spawn_async_with_callback(), hal_device::udi, and unmount_volume_finished().

Referenced by on_volume_unmounted(), unmount_volumes(), and volume_is_mounted().

{
    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();
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unmount_volume_finished

(

void

)

[static]

Definition at line 1142 of file hal.c.

References g_unmount_callback_data, g_unmount_callback_func, and LOGPRINTF.

Referenced by on_volume_unmounted(), unmount_volume(), and unmount_volumes().

{
    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");
    }
}

Here is the caller graph for this function:

static void unmount_volumes

(

void

)

[static]

Definition at line 1105 of file hal.c.

References hal_device_list_get_root(), LOGPRINTF, unmount_volume(), and unmount_volume_finished().

Referenced by hal_unmount_all_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();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void volume_is_mounted	(	LibHalContext *	ctx,
		const char *	udi
	)			[static]

Definition at line 1008 of file hal.c.

References ERRORPRINTF, g_remount_all_volumes, hal_device_list_find_device(), ipc_send_volume_mounted(), ipc_show_splash(), LOGPRINTF, MOUNTPOINT_CARD, remount_next_volume(), SD_FREE_MB_ERROR_LEVEL, STATE_CARD_INACCESSIBLE, STATE_CARD_INDEXING, STATE_CARD_MOUNTED, sys_is_emulator(), sys_reset_idle_time(), sys_set_card(), and unmount_volume().

Referenced by hal_add_devices(), and hal_device_property_modified().

{
    // 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();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

gboolean g_remount_all_volumes = FALSE [static]

Definition at line 79 of file hal.c.

Referenced by hal_remount_all_volumes(), remount_next_volume(), and volume_is_mounted().

gpointer g_remount_callback_data = NULL [static]

Definition at line 80 of file hal.c.

Referenced by hal_remount_all_volumes(), and remount_next_volume().

void(* g_remount_callback_func)(gpointer user_data) [static]

Referenced by hal_remount_all_volumes(), and remount_next_volume().

gboolean g_unmount_all_volumes = FALSE [static]

Definition at line 75 of file hal.c.

Referenced by hal_unmount_all_volumes(), and on_volume_unmounted().

gpointer g_unmount_callback_data = NULL [static]

Definition at line 76 of file hal.c.

Referenced by hal_unmount_all_volumes(), and unmount_volume_finished().

void(* g_unmount_callback_func)(gpointer user_data) [static]

Referenced by hal_unmount_all_volumes(), and unmount_volume_finished().

LibHalContext* halContext = NULL [static]

Definition at line 74 of file hal.c.

Referenced by hal_add_devices(), hal_device_print(), hal_get_property_value(), hal_property_matches_udi(), hal_set_services(), hal_udi_property_value(), and udi_is_internal_mmc_host().

const gint SD_FREE_MB_ERROR_LEVEL = 1 [static]

Definition at line 67 of file hal.c.

Referenced by volume_is_mounted().

const gchar* UDI_MMC_HOST = "/org/freedesktop/Hal/devices/platform_mxcmci_0_mmc_host" [static]

Definition at line 66 of file hal.c.

Referenced by device_is_internal_mmc_host(), and udi_is_internal_mmc_host().