devicelist.c

Go to the documentation of this file.

/*
 * File Name: devicelist.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 <string.h>

// ereader include files, between < >

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

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


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


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

static hal_device *hal_device_root;


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


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

void hal_free_property_value(char **values)
{
    LOGPRINTF("entry");

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


void hal_free_device_property(hal_device_property *property)
{
    LOGPRINTF("entry");

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


void hal_free_device(hal_device *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;
}


hal_device_property *hal_new_device_property(char *key, char **values)
{
//    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;
}


hal_device *hal_device_list_add_device(LibHalContext *ctx, const char *udi)
{
    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;
}


gboolean hal_device_list_remove_device(const char *udi)
{
    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;
}


hal_device *hal_device_list_find_device(const char *udi)
{
    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;
}


hal_device_property *hal_device_list_get_property(const char *key, const hal_device *device)
{
//    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;
}


hal_device *hal_device_list_get_root()
{
    return hal_device_root;
}

 
gboolean hal_device_list_set_property(const char *udi, const char *key)
{
    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;
}


gboolean hal_device_list_remove_property(const char *udi, const char *key)
{
    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;
}


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


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