devicelist.c File Reference

#include <glib.h>
#include <hal/libhal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "devicelist.h"
#include "hal.h"
#include "log.h"

Include dependency graph for devicelist.c:

Go to the source code of this file.

Functions
void	hal_free_property_value (char **values)
void	hal_free_device_property (hal_device_property *property)
void	hal_free_device (hal_device *device)
hal_device_property *	hal_new_device_property (char *key, char **values)
hal_device *	hal_device_list_add_device (LibHalContext *ctx, const char *udi)
	Add udi to device list.
gboolean	hal_device_list_remove_device (const char *udi)
	Remove udi from device list.
hal_device *	hal_device_list_find_device (const char *udi)
	Return the device pointed to by udi.
hal_device_property *	hal_device_list_get_property (const char *key, const hal_device *device)
	Return the property of the given device.
hal_device *	hal_device_list_get_root ()
	Get device llst root.
gboolean	hal_device_list_set_property (const char *udi, const char *key)
	Set property of udi from device list.
gboolean	hal_device_list_remove_property (const char *udi, const char *key)
	Remove property of udi from device list.
void	hal_print_all_devices ()
	Print all available devices (for debugging).
int	hal_count_devices ()
	Return the number of devices available.
Variables
static hal_device *	hal_device_root

---

Function Documentation

int hal_count_devices

(

)

Return the number of devices available.

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

Name : hal_count_devices

Returns:

Number of devices

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

Definition at line 397 of file devicelist.c.

References hal_device::next.

{
    int nr = 0;
    hal_device *device = hal_device_root;
    while (device != NULL)
    {
        nr++;
        device = device->next;
    }
    return nr;
}

hal_device* hal_device_list_add_device	(	LibHalContext *	ctx,
		const char *	udi
	)

Add udi to device list.

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

Name : hal_device_list_add_device

Parameters:

	ctx	HAL context
	udi	Unique Device Id

Returns:

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

Definition at line 135 of file devicelist.c.

References hal_check_dbus_error(), hal_free_device(), hal_free_property_value(), hal_get_iterator_value(), hal_new_device_property(), LOGPRINTF, hal_device::next, hal_device_property::next, hal_device::properties, and hal_device::udi.

Referenced by hal_add_devices(), and hal_device_added().

{
    LOGPRINTF("entry: udi %s", udi);

    DBusError dbus_error;
    LibHalPropertySet *pset = NULL;
    LibHalPropertySetIterator it;
    hal_device *device = NULL;
    char *key = NULL;
    char **value;
    hal_device_property *new_property = NULL;

    dbus_error_init(&dbus_error);
    
    device = g_try_malloc0(sizeof(hal_device));
    if (device == NULL) 
    { 
        goto oom;
    }
    device->properties = NULL;

    pset = libhal_device_get_all_properties(ctx, udi, &dbus_error);
    hal_check_dbus_error(&dbus_error);
    if (pset == NULL)
    {
        goto oom;
    }

    for (libhal_psi_init(&it, pset); libhal_psi_has_more(&it); libhal_psi_next(&it))
    {
        LibHalPropertyType type = libhal_psi_get_type(&it);
        key = g_strdup(libhal_psi_get_key(&it));
        if (key == NULL) 
        { 
            goto oom; 
        }
        
        value = hal_get_iterator_value(type, &it);
        if (value == NULL) 
        { 
            g_free(key);
            goto oom; 
        }

        new_property = hal_new_device_property(key, value);
        if (new_property == NULL) 
        { 
            hal_free_property_value(value);
            g_free(key);
            goto oom; 
        }
        new_property->next = device->properties;
        device->properties = new_property;
    }
    
    device->next = hal_device_root;
    device->udi = g_strdup(udi);
    if (device->udi == NULL) 
    { 
        goto oom;
    }
    hal_device_root = device;
    
    libhal_free_property_set(pset); 
    
    return device;

oom:
    LOGPRINTF("No property found for %s (or oom)", udi);

    if (device) 
        hal_free_device(device);
    if (pset) 
        libhal_free_property_set(pset); 
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hal_device* hal_device_list_find_device

(

const char *

udi

)

Return the device pointed to by udi.

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

Name : hal_device_list_find_device

Parameters:

udi

Unique Device Id

Returns:

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

Definition at line 253 of file devicelist.c.

References LOGPRINTF, hal_device::next, and hal_device::udi.

Referenced by device_is_internal_mmc_host(), hal_device_list_remove_property(), hal_device_list_set_property(), hal_device_property_modified(), hal_device_removed(), and volume_is_mounted().

{
    LOGPRINTF("entry: udi %s", udi);
    
    g_return_val_if_fail(udi!=NULL, NULL);

    hal_device *device = hal_device_root;
    while (device != NULL)
    {
        if (device->udi && (strcmp(device->udi, udi)==0)) 
        { 
            return device; 
        }
        device = device->next;
    }
    return NULL;
}

Here is the caller graph for this function:

hal_device_property* hal_device_list_get_property	(	const char *	property,
		const hal_device *	device
	)

Return the property of the given device.

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

Name : hal_device_list_get_property

Parameters:

	property
	device

Returns:

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

Definition at line 272 of file devicelist.c.

References LOGPRINTF, and hal_device::properties.

Referenced by device_is_internal_mmc_host(), hal_device_list_set_property(), hal_device_property_modified(), hal_get_mountpoint_device(), hal_property_value(), remount_next_volume(), report_unmounting_volumes(), and unmount_volume().

{
//    LOGPRINTF("entry: key %s", key);
    
    g_return_val_if_fail(key!=NULL, NULL);
    
    if (device == NULL)
    {
        return NULL;
    }

    hal_device_property *property = device->properties;
    while (property != NULL)
    {
        if (property->key && (strcmp(property->key, key)==0))
        {
            LOGPRINTF("entry found: key %s, property %p, %p, %s", key, property->values, *property->values, *property->values);
            return property;
        }
        property = property->next;
    }
    return NULL;
}

Here is the caller graph for this function:

hal_device* hal_device_list_get_root

(

)

Get device llst root.

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

Name : hal_device_list_get_root

Parameters:

--

Returns:

Returns root of device list

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

Definition at line 297 of file devicelist.c.

Referenced by hal_get_mountpoint_device(), remount_next_volume(), report_unmounting_volumes(), and unmount_volumes().

{
    return hal_device_root;
}

Here is the caller graph for this function:

gboolean hal_device_list_remove_device

(

const char *

udi

)

Remove udi from device list.

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

Name : hal_device_list_remove_device

Parameters:

udi

Unique Device Id

Returns:

Returns TRUE on success, FALSE on failure

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

Definition at line 213 of file devicelist.c.

References hal_free_device(), LOGPRINTF, hal_device::next, and hal_device::udi.

Referenced by hal_device_removed().

{
    LOGPRINTF("entry: udi %s", udi);

    g_return_val_if_fail(udi!=NULL, FALSE);

    hal_device *previous = hal_device_root;
    hal_device *device = hal_device_root;

    // no device 
    if (device == NULL) 
    {
        return FALSE; 
    }

    LOGPRINTF("Removing %s", udi);

    // device is the first one 
    if (device->udi && (strcmp(device->udi, udi)==0))
    {
        hal_device_root = device->next;
        hal_free_device(device);
        return TRUE;
    }

    while (device != NULL)
    {
        if (device->udi && (strcmp(device->udi, udi)==0))
        {
            previous->next = device->next;
            hal_free_device(device);
            return TRUE;
        }
        previous = device;
        device = device->next;
    }
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean hal_device_list_remove_property	(	const char *	udi,
		const char *	key
	)

Remove property of udi from device list.

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

Name : hal_device_list_remove_property

Parameters:

	udi	Unique Device Id
	key

Returns:

Returns TRUE on success, FALSE on failure

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

Definition at line 351 of file devicelist.c.

References hal_device_list_find_device(), hal_free_device_property(), LOGPRINTF, hal_device_property::next, and hal_device::properties.

Referenced by hal_device_property_modified().

{
    LOGPRINTF("entry: udi %s", udi);

    hal_device *device = hal_device_list_find_device(udi);
    if (device == NULL || device->properties == NULL) 
    { 
        return FALSE; 
    }

    hal_device_property *property = device->properties;
    // first property 
    if (property->key && (strcmp(property->key, key)==0))
    {
        device->properties = property->next;
        hal_free_device_property(property);
    }
    
    hal_device_property *previous = property;

    while (property != NULL)
    {
        if (property->key && (strcmp(property->key, key)==0))
        {
            previous->next = property->next;
            hal_free_device_property(property);
            return TRUE;
        }
        previous = property;
        property = property->next;
    }
    return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean hal_device_list_set_property	(	const char *	udi,
		const char *	key
	)

Set property of udi from device list.

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

Name : hal_device_list_set_property

Parameters:

	udi	Unique Device Id
	key

Returns:

Returns TRUE on success, FALSE on failure

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

Definition at line 303 of file devicelist.c.

References hal_device_list_find_device(), hal_device_list_get_property(), hal_free_property_value(), hal_new_device_property(), hal_property_value(), LOGPRINTF, hal_device::properties, and hal_device_property::values.

Referenced by hal_device_property_modified().

{
    LOGPRINTF("entry: udi %s", udi);

    hal_device *device = hal_device_list_find_device(udi);
    hal_device_property *property;

    char **values;

    if (device == NULL) 
    {
        return FALSE; 
    }

    values = hal_property_value(key, udi, NULL);
    if (values == NULL) 
    {
        return FALSE; 
    }

    property = hal_device_list_get_property(key, device);
    if (property != NULL)
    {
        hal_free_property_value(property->values);
        property->values = values;
    }
    else
    {
        char *new_key = g_strdup(key);
        if (new_key == NULL)
        {
            hal_free_property_value(values);
            return FALSE; 
        }
        property = hal_new_device_property(new_key, values);
        if (property == NULL) 
        {
            hal_free_property_value(values);
            g_free(new_key);
            return FALSE; 
        }
        property->next = device->properties;
        device->properties = property;
    }
    return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_free_device

(

hal_device *

device

)

Definition at line 99 of file devicelist.c.

References LOGPRINTF, hal_device_property::next, hal_device::properties, and hal_device::udi.

Referenced by hal_device_list_add_device(), and hal_device_list_remove_device().

{
    LOGPRINTF("entry");

    hal_device_property *property = device->properties;
    hal_device_property *previous_property;

    g_free(device->udi);
    
    while (property != NULL)
    {
        previous_property = property;
        property = property->next;
        g_free(previous_property);
    }
    
    g_free(device);
    device = NULL;
}

Here is the caller graph for this function:

void hal_free_device_property

(

hal_device_property *

property

)

Definition at line 89 of file devicelist.c.

References hal_free_property_value(), hal_device_property::key, LOGPRINTF, and hal_device_property::values.

Referenced by hal_device_list_remove_property().

{
    LOGPRINTF("entry");

    g_free(property->key);
    property->key = NULL;
    hal_free_property_value(property->values);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void hal_free_property_value

(

char **

values

)

Definition at line 73 of file devicelist.c.

References LOGPRINTF.

Referenced by hal_device_list_add_device(), hal_device_list_set_property(), and hal_free_device_property().

{
    LOGPRINTF("entry");

    char **cur_value = values;
    
    while ((*cur_value) != NULL)
    {
        g_free(*cur_value);
        cur_value++;
    }
    g_free(values);
    values = NULL;
}

Here is the caller graph for this function:

hal_device_property* hal_new_device_property	(	char *	key,
		char **	values
	)

Definition at line 120 of file devicelist.c.

References hal_device_property::key, and hal_device_property::values.

Referenced by hal_device_list_add_device(), and hal_device_list_set_property().

{
//    LOGPRINTF("entry: key %s", key);

    hal_device_property *new_property = g_try_malloc0(sizeof(hal_device_property));
    if (new_property == NULL) 
    { 
        return NULL; 
    }
    new_property->values = values;
    new_property->key = key;
    return new_property;
}

Here is the caller graph for this function:

void hal_print_all_devices

(

)

Print all available devices (for debugging).

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

Name : hal_print_all_devices

Returns:

--

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

Definition at line 386 of file devicelist.c.

References hal_device_print(), hal_device::next, and hal_device::udi.

{
    hal_device *device = hal_device_root;
    while (device != NULL)
    {
        hal_device_print(device->udi);
        device = device->next;
    }
}

Here is the call graph for this function:

---

Variable Documentation

hal_device* hal_device_root [static]

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 61 of file devicelist.c.