OpenSolaris_b135/cmd/hal/tools/hal-device.c
/***************************************************************************
* CVSID: $Id$
*
* hal-device.c : add devices HAL
*
* Copyright (C) 2005 SuSE Linux Gmbh
*
* Authors:
* Steffen Winterfeldt <snwint@suse.de>
*
* Licensed under the Academic Free License version 2.1
*
* This program 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.
*
* This program 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, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#define _GNU_SOURCE
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <ctype.h>
#include <inttypes.h>
#include <getopt.h>
#ifndef DBUS_API_SUBJECT_TO_CHANGE
#define DBUS_API_SUBJECT_TO_CHANGE 1
#endif
#include <dbus/dbus.h>
#include <libhal.h>
typedef struct {
char *udi;
char *real_udi;
} new_dev_t;
typedef struct lh_prop_s {
struct lh_prop_s *next;
LibHalPropertyType type;
char *key;
union {
char *str_value;
dbus_int32_t int_value;
dbus_uint64_t uint64_value;
double double_value;
dbus_bool_t bool_value;
char **strlist_value;
} v;
} lh_prop_t;
void help(void);
int dump_devices(LibHalContext *hal_ctx, char *arg);
int remove_udi(LibHalContext *hal_ctx, char *arg);
int add_udi(LibHalContext *hal_ctx, char *arg);
void process_property(LibHalContext *hal_ctx, char *buf, lh_prop_t **prop);
int add_properties(LibHalContext *hal_ctx, new_dev_t *nd, lh_prop_t *prop);
lh_prop_t *free_properties(lh_prop_t *prop);
static char *skip_space(char *s);
static char *skip_non_eq_or_space(char *s);
static char *skip_number(char *s);
static char *skip_nonquote(char *s);
new_dev_t new_dev;
struct {
unsigned remove:1;
unsigned add:1;
unsigned list:1;
char *udi;
} opt;
struct option options[] = {
{ "remove", 1, NULL, 'r' },
{ "add", 1, NULL, 'a' },
{ "help", 0, NULL, 'h' },
{ 0, 0, 0, 0 }
};
int main(int argc, char **argv)
{
DBusError error;
DBusConnection *conn;
LibHalContext *hal_ctx;
int i, err;
opterr = 0;
opt.list = 1;
while ((i = getopt_long(argc, argv, "a:hr:", options, NULL)) != -1) {
switch (i) {
case 'a':
opt.add = 1;
opt.list = 0;
opt.udi = optarg;
break;
case 'r':
opt.remove = 1;
opt.list = 0;
opt.udi = optarg;
break;
case 'h':
help();
return 0;
default:
help();
return 1;
}
}
dbus_error_init(&error);
if (!(conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
fprintf(stderr, "error: dbus_bus_get: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 2;
}
/* fprintf(stderr, "connected to: %s\n", dbus_bus_get_unique_name(conn)); */
if (!(hal_ctx = libhal_ctx_new())) return 3;
if (!libhal_ctx_set_dbus_connection(hal_ctx, conn)) return 4;
if (!libhal_ctx_init(hal_ctx, &error)) {
if (dbus_error_is_set(&error)) {
fprintf (stderr, "error: libhal_ctx_init: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
}
fprintf (stderr, "Could not initialise connection to hald.\n"
"Normally this means the HAL daemon (hald) is not running or not ready.\n");
return 5;
}
err = 0;
if (opt.list)
err = dump_devices(hal_ctx, argv[optind]);
else if (opt.remove)
err = remove_udi(hal_ctx, opt.udi);
else if (opt.add)
err = add_udi(hal_ctx, opt.udi);
else
err = 6;
libhal_ctx_shutdown(hal_ctx, &error);
libhal_ctx_free(hal_ctx);
dbus_connection_unref(conn);
dbus_error_free(&error);
return err;
}
void help()
{
fprintf(stderr,
"usage: hal-device [--help] [--add udi] [--remove udi] [udi]\n"
"Create, remove, or show HAL device. If no udi is given, shows all devices.\n"
"If udi doesn't start with a '/', '/org/freedesktop/Hal/devices/' is prepended.\n"
" -a, --add udi\t\tAdd new device.\n"
" \t\t\tReads property list in 'lshal' syntax from stdin.\n"
" -r, --remove udi\tRemove device.\n"
" -h, --help\t\tShow this text.\n"
);
}
/*
* Dump all devices.
*/
int dump_devices(LibHalContext *hal_ctx, char *arg)
{
int i;
int num_devices;
char **device_names;
DBusError error;
char *udi = NULL;
if (arg) {
if (*arg == '/') {
udi = arg;
} else {
#ifdef HAVE_ASPRINTF
asprintf(&udi, "/org/freedesktop/Hal/devices/%s", arg);
#else
udi = calloc(1, sizeof ("/org/freedesktop/Hal/devices/%s") + strlen(arg));
sprintf(udi, "/org/freedesktop/Hal/devices/%s", arg);
#endif
}
}
dbus_error_init(&error);
if (!udi) {
if (!(device_names = libhal_get_all_devices(hal_ctx, &num_devices, &error))) {
fprintf(stderr, "Empty HAL device list.\n");
LIBHAL_FREE_DBUS_ERROR (&error);
return 31;
}
} else {
device_names = calloc(2, sizeof *device_names);
device_names[0] = strdup(udi);
num_devices = 1;
}
for(i = 0; i < num_devices; i++) {
LibHalPropertySet *props;
LibHalPropertySetIterator it;
int type;
if (!(props = libhal_device_get_all_properties(hal_ctx, device_names[i], &error))) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
dbus_error_init(&error);
continue;
}
if (!udi)
printf("%d: ", i);
printf("udi = '%s'\n", device_names[i]);
for(libhal_psi_init(&it, props); libhal_psi_has_more(&it); libhal_psi_next(&it)) {
type = libhal_psi_get_type(&it);
switch (type) {
case LIBHAL_PROPERTY_TYPE_STRING:
printf(" %s = '%s' (string)\n",
libhal_psi_get_key(&it),
libhal_psi_get_string(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_INT32:
printf(" %s = %d (0x%x) (int)\n",
libhal_psi_get_key(&it),
libhal_psi_get_int(&it),
libhal_psi_get_int(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
printf(" %s = %lld (0x%llx) (uint64)\n",
libhal_psi_get_key(&it),
(long long) libhal_psi_get_uint64(&it),
(long long) libhal_psi_get_uint64(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
printf(" %s = %g (double)\n",
libhal_psi_get_key(&it),
libhal_psi_get_double(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
printf(" %s = %s (bool)\n",
libhal_psi_get_key(&it),
libhal_psi_get_bool(&it) ? "true" : "false"
);
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
{
char **strlist;
printf (" %s = { ", libhal_psi_get_key(&it));
strlist = libhal_psi_get_strlist(&it);
while (*strlist) {
printf("'%s'%s", *strlist, strlist[1] ? ", " : "");
strlist++;
}
printf(" } (string list)\n");
}
break;
default:
printf("Unknown type %d = 0x%02x\n", type, type);
break;
}
}
libhal_free_property_set(props);
printf("\n");
}
libhal_free_string_array(device_names);
dbus_error_free(&error);
return 0;
}
int remove_udi(LibHalContext *hal_ctx, char *arg)
{
DBusError error;
char *udi;
if (!arg) return 11;
if (*arg == '/') {
udi = arg;
} else {
#ifdef HAVE_ASPRINTF
asprintf(&udi, "/org/freedesktop/Hal/devices/%s", arg);
#else
udi = calloc(1, sizeof ("/org/freedesktop/Hal/devices/%s") + strlen(arg));
sprintf(udi, "/org/freedesktop/Hal/devices/%s", arg);
#endif
}
dbus_error_init(&error);
if (opt.remove) {
if (!libhal_remove_device(hal_ctx, udi, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 12;
}
fprintf(stderr, "removed: %s\n", udi);
return 13;
}
return 0;
}
int add_udi(LibHalContext *hal_ctx, char *arg)
{
DBusError error;
dbus_bool_t dev_exists = FALSE;
char *udi = NULL, buf[1024];
lh_prop_t *prop;
int err;
if (!arg)
return 21;
if (*arg == '/') {
udi = arg;
} else {
#ifdef HAVE_ASPRINTF
asprintf(&udi, "/org/freedesktop/Hal/devices/%s", arg);
#else
udi = calloc(1, sizeof ("/org/freedesktop/Hal/devices/%s") + strlen(arg));
sprintf(udi, "/org/freedesktop/Hal/devices/%s", arg);
#endif
}
if (udi)
new_dev.udi = strdup(udi);
dbus_error_init(&error);
if (udi)
dev_exists = libhal_device_exists(hal_ctx, udi, &error);
if (dev_exists) {
new_dev.real_udi = strdup(new_dev.udi);
} else {
new_dev.real_udi = libhal_new_device(hal_ctx, &error);
if (!new_dev.real_udi) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
free(new_dev.real_udi);
return 22;
}
printf("tmp udi: %s\n", new_dev.real_udi);
}
prop = NULL;
while (fgets(buf, sizeof buf, stdin)) {
process_property(hal_ctx, buf, &prop);
}
err = add_properties(hal_ctx, &new_dev, prop);
prop = free_properties(prop);
if (!dev_exists) {
if (!libhal_device_commit_to_gdl(hal_ctx, new_dev.real_udi, new_dev.udi, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
free(new_dev.real_udi);
err = err ? err : 23;
}
}
printf("%s: %s\n", dev_exists ? "merged": "created", new_dev.udi);
return err;
}
char *skip_space(char *s)
{
while (isspace(*s)) s++;
return s;
}
char *skip_non_eq_or_space(char *s)
{
while (*s && *s != '=' && !isspace(*s))
s++;
return s;
}
char *skip_number(char *s)
{
while (*s == '-' || *s == '+' || *s == '.' || isdigit(*s))
s++;
return s;
}
char *skip_nonquote(char *s)
{
while (*s && *s != '\'')
s++;
return s;
}
void process_property(LibHalContext *hal_ctx, char *buf, lh_prop_t **prop)
{
char *s, *s1;
char *key, *s_val = NULL;
lh_prop_t *p;
unsigned len;
int remove = 0;
s = skip_space(buf);
if (*s == '-') {
remove = 1;
s = skip_space(s + 1);
}
if ((s1 = skip_number(s), s1 != s) && *s1 == ':') s = skip_space(s1 + 1);
s = skip_non_eq_or_space(key = s);
*s++ = 0;
if (!*key)
return;
if (*key == '#')
return;
if (*s == '=')
s++;
s = skip_space(s);
if (!*s)
remove = 1;
p = calloc(1, sizeof *p);
p->type = LIBHAL_PROPERTY_TYPE_INVALID;
p->key = strdup(key);
if (remove) {
p->next = *prop;
*prop = p;
return;
}
if (*s == '\'') {
s_val = s + 1;
s = strrchr(s_val, '\'');
*(s ? s : s_val) = 0;
p->type = LIBHAL_PROPERTY_TYPE_STRING;
p->v.str_value = strdup(s_val);
} else if (*s == '{') {
s_val = s + 1;
s1 = strrchr(s_val, '}');
if (s1) *s1 = 0;
p->type = LIBHAL_PROPERTY_TYPE_STRLIST;
len = 0;
p->v.strlist_value = calloc(1, sizeof *p->v.strlist_value);
while (*s_val++ == '\'') {
s = skip_nonquote(s_val);
if (*s) *s++ = 0;
p->v.strlist_value = realloc(p->v.strlist_value, (len + 2) * sizeof *p->v.strlist_value);
p->v.strlist_value[len] = strdup(s_val);
p->v.strlist_value[++len] = NULL;
s_val = skip_nonquote(s);
}
} else if (!strncmp(s, "true", 4)) {
s += 4;
p->type = LIBHAL_PROPERTY_TYPE_BOOLEAN;
p->v.bool_value = TRUE;
} else if (!strncmp(s, "false", 5)) {
s += 5;
p->type = LIBHAL_PROPERTY_TYPE_BOOLEAN;
p->v.bool_value = FALSE;
} else if ((s1 = skip_number(s)) != s) {
if (strstr(s1, "(int)")) {
*s1++ = 0;
p->type = LIBHAL_PROPERTY_TYPE_INT32;
p->v.int_value = strtol(s, NULL, 10);
} else if (strstr(s1, "(uint64)")) {
*s1++ = 0;
p->type = LIBHAL_PROPERTY_TYPE_UINT64;
p->v.uint64_value = strtoull(s, NULL, 10);
} else if (strstr(s1, "(double)")) {
p->type = LIBHAL_PROPERTY_TYPE_DOUBLE;
p->v.double_value = strtod(s, NULL);
}
s = s1;
}
if (p->type == LIBHAL_PROPERTY_TYPE_INVALID) {
free(p->key);
free(p);
} else {
p->next = *prop;
*prop = p;
}
}
int add_properties(LibHalContext *hal_ctx, new_dev_t *nd, lh_prop_t *prop)
{
DBusError error;
lh_prop_t *p;
char *udi2 = NULL, *udi3 = NULL, **s;
LibHalPropertyType old_type;
dbus_error_init(&error);
for(p = prop; p; p = p->next) {
if (!strcmp(p->key, "udi") && p->type == LIBHAL_PROPERTY_TYPE_STRING) {
udi2 = p->v.str_value;
continue;
}
old_type = libhal_device_get_property_type(hal_ctx, nd->real_udi, p->key, &error);
dbus_error_init(&error);
if (old_type != LIBHAL_PROPERTY_TYPE_INVALID &&
( p->type != old_type || p->type == LIBHAL_PROPERTY_TYPE_STRLIST)) {
if (!libhal_device_remove_property(hal_ctx, nd->real_udi, p->key, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 41;
}
}
switch (p->type) {
case LIBHAL_PROPERTY_TYPE_INVALID:
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
if (!libhal_device_set_property_bool(hal_ctx, nd->real_udi, p->key, p->v.bool_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_INT32:
if (!libhal_device_set_property_int(hal_ctx, nd->real_udi, p->key, p->v.int_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
if (!libhal_device_set_property_uint64(hal_ctx, nd->real_udi, p->key, p->v.uint64_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
if (!libhal_device_set_property_double(hal_ctx, nd->real_udi, p->key, p->v.double_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_STRING:
if (!strcmp(p->key, "info.udi")) udi3 = p->v.str_value;
if (!libhal_device_set_property_string(hal_ctx, nd->real_udi, p->key, p->v.str_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
for(s = p->v.strlist_value; *s; s++) {
if (!libhal_device_property_strlist_append(hal_ctx, nd->real_udi, p->key, *s, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
}
break;
}
}
if (udi2) udi3 = NULL;
if (udi3) udi2 = udi3;
if (udi2 && !nd->udi)
nd->udi = strdup(udi2);
return 0;
}
lh_prop_t *free_properties(lh_prop_t *prop)
{
lh_prop_t *next;
char **s;
for(; prop; prop = next) {
next = prop->next;
free(prop->key);
if (prop->type == LIBHAL_PROPERTY_TYPE_STRING) free(prop->v.str_value);
if (prop->type == LIBHAL_PROPERTY_TYPE_STRLIST && prop->v.strlist_value) {
for(s = prop->v.strlist_value; *s; ) free(*s++);
free(prop->v.strlist_value);
}
free(prop);
}
return NULL;
}