ldetect/trunk/hid.c

#include <sys/types.h>
#include <dirent.h>
#include <fnmatch.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libkmod.h>

#include "libsysfs.h"
#include "libldetect.h"
#include "common.h"


#define HID_BUS_NAME "hid"
const char *sysfs_hid_path = "/sys/bus/"HID_BUS_NAME"/devices";
#if 0
#define DEBUG(args...) printf(args)
#else 
#define DEBUG(args...)
#endif

#if 0
struct module_alias {
    const char      *modalias;
    const char      *module;
};

static struct module_alias aliasdb[] = { {NULL, NULL} };
static const char *resolve_modalias(const struct module_alias *aliasdb,
                                    const char *alias_name)
{
    const struct module_alias *alias = aliasdb;

    while (alias->modalias != NULL) {
        if (fnmatch(alias->modalias, alias_name, 0) == 0) 
            return alias->module;

        alias++;
    }
    return NULL;
}
#endif

static char *get_field_value(const char *fields, const char *field_name)
{
        char *modalias;
        char *end;

        modalias = strstr(fields, field_name);
        if (modalias == NULL)
                return NULL;
        end = strchr(modalias, '\n');
        if (end == NULL)
                end = modalias + strlen(modalias);

        return strndup(modalias+strlen(field_name), end - (modalias+strlen(field_name)));
}

static char *parse_modalias(char *fields)
{
        return get_field_value(fields, "MODALIAS=");
}

static char *parse_name(char *fields)
{
        return get_field_value(fields, "HID_NAME=");
}

static void add_entry(struct hid_entries *entry_list, char *name, char *module)
{
    
        struct hid_entry *new_entries;

        new_entries = realloc(entry_list->entries, (entry_list->nb+1)*sizeof(*(entry_list->entries)));
        if (new_entries != NULL) {
                new_entries[entry_list->nb].module = module;
                new_entries[entry_list->nb].text = name;
                entry_list->entries = new_entries;
                entry_list->nb++;
        }
}

static void parse_device(struct kmod_ctx *ctx, struct hid_entries *entries, const char *dev)
{
        char keyfile[SYSFS_PATH_MAX];
        char *modalias;
        char *modname;
        char *device_name;
        struct sysfs_attribute *sysfs_attr;

        snprintf(keyfile, sizeof(keyfile)-1, "%s/%s/uevent",
                        sysfs_hid_path, dev);
        sysfs_attr = sysfs_open_attribute(keyfile);
        if (!sysfs_attr)
                return;
        if (sysfs_read_attribute(sysfs_attr) != 0 || !sysfs_attr->value) {
                sysfs_close_attribute(sysfs_attr);
                return;
        }

        DEBUG("%s: read %s\n", HID_BUS_NAME, sysfs_attr->value);

        modalias = parse_modalias(sysfs_attr->value);
        if (modalias == NULL)
                return;
        DEBUG("%s: modalias is [%s]\n", HID_BUS_NAME, modalias);

        device_name = parse_name(sysfs_attr->value);
        sysfs_close_attribute(sysfs_attr);
        if (device_name != NULL) 
                DEBUG("%s: device name is [%s]\n", HID_BUS_NAME, device_name);
        else 
                device_name = strdup("HID Device");

        modname = modalias_resolve_module(ctx, modalias);
        free(modalias);
        DEBUG("%s: module name is [%s]\n", HID_BUS_NAME, modname);
        if (modname != NULL) 
                add_entry(entries, device_name, modname);
}


struct hid_entries hid_probe(void)
{
        DIR *dir;
        struct dirent *dent;
        struct hid_entries entry_list = {NULL, 0};
        struct kmod_ctx *ctx = modalias_init();

        dir = opendir(sysfs_hid_path);
        if (dir == NULL)
                goto end_probe;

        for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
                if (dent->d_name[0] == '.')
                        continue;
                DEBUG("%s: device found %s\n", HID_BUS_NAME, dent->d_name);
                parse_device(ctx, &entry_list, dent->d_name);
        }

end_probe:
        modalias_cleanup(ctx);
        if (dir)
                closedir(dir);

        return entry_list;
}

void hid_entries_free(struct hid_entries *entries)
{
        unsigned int i;
        for (i = 0; i < entries->nb; i++) {
            free(entries->entries[i].module);
            free(entries->entries[i].text);
        }
        free(entries->entries);
}
1	#include <sys/types.h>
2	#include <dirent.h>
3	#include <fnmatch.h>
4	#include <stdio.h>
5	#include <stdlib.h>
6	#include <string.h>
7	#include <libkmod.h>
8
9	#include "libsysfs.h"
10	#include "libldetect.h"
11	#include "common.h"
12
13
14	#define HID_BUS_NAME "hid"
15	const char *sysfs_hid_path = "/sys/bus/"HID_BUS_NAME"/devices";
16	#if 0
17	#define DEBUG(args...) printf(args)
18	#else
19	#define DEBUG(args...)
20	#endif
21
22	#if 0
23	struct module_alias {
24	const char *modalias;
25	const char *module;
26	};
27
28	static struct module_alias aliasdb[] = { {NULL, NULL} };
29	static const char resolve_modalias(const struct module_alias aliasdb,
30	const char *alias_name)
31	{
32	const struct module_alias *alias = aliasdb;
33
34	while (alias->modalias != NULL) {
35	if (fnmatch(alias->modalias, alias_name, 0) == 0)
36	return alias->module;
37
38	alias++;
39	}
40	return NULL;
41	}
42	#endif
43
44	static char get_field_value(const char fields, const char *field_name)
45	{
46	char *modalias;
47	char *end;
48
49	modalias = strstr(fields, field_name);
50	if (modalias == NULL)
51	return NULL;
52	end = strchr(modalias, '\n');
53	if (end == NULL)
54	end = modalias + strlen(modalias);
55
56	return strndup(modalias+strlen(field_name), end - (modalias+strlen(field_name)));
57	}
58
59	static char parse_modalias(char fields)
60	{
61	return get_field_value(fields, "MODALIAS=");
62	}
63
64	static char parse_name(char fields)
65	{
66	return get_field_value(fields, "HID_NAME=");
67	}
68
69	static void add_entry(struct hid_entries entry_list, char name, char *module)
70	{
71
72	struct hid_entry *new_entries;
73
74	new_entries = realloc(entry_list->entries, (entry_list->nb+1)sizeof((entry_list->entries)));
75	if (new_entries != NULL) {
76	new_entries[entry_list->nb].module = module;
77	new_entries[entry_list->nb].text = name;
78	entry_list->entries = new_entries;
79	entry_list->nb++;
80	}
81	}
82
83	static void parse_device(struct kmod_ctx ctx, struct hid_entries entries, const char *dev)
84	{
85	char keyfile[SYSFS_PATH_MAX];
86	char *modalias;
87	char *modname;
88	char *device_name;
89	struct sysfs_attribute *sysfs_attr;
90
91	snprintf(keyfile, sizeof(keyfile)-1, "%s/%s/uevent",
92	sysfs_hid_path, dev);
93	sysfs_attr = sysfs_open_attribute(keyfile);
94	if (!sysfs_attr)
95	return;
96	if (sysfs_read_attribute(sysfs_attr) != 0 \|\| !sysfs_attr->value) {
97	sysfs_close_attribute(sysfs_attr);
98	return;
99	}
100
101	DEBUG("%s: read %s\n", HID_BUS_NAME, sysfs_attr->value);
102
103	modalias = parse_modalias(sysfs_attr->value);
104	if (modalias == NULL)
105	return;
106	DEBUG("%s: modalias is [%s]\n", HID_BUS_NAME, modalias);
107
108	device_name = parse_name(sysfs_attr->value);
109	sysfs_close_attribute(sysfs_attr);
110	if (device_name != NULL)
111	DEBUG("%s: device name is [%s]\n", HID_BUS_NAME, device_name);
112	else
113	device_name = strdup("HID Device");
114
115	modname = modalias_resolve_module(ctx, modalias);
116	free(modalias);
117	DEBUG("%s: module name is [%s]\n", HID_BUS_NAME, modname);
118	if (modname != NULL)
119	add_entry(entries, device_name, modname);
120	}
121
122
123	struct hid_entries hid_probe(void)
124	{
125	DIR *dir;
126	struct dirent *dent;
127	struct hid_entries entry_list = {NULL, 0};
128	struct kmod_ctx *ctx = modalias_init();
129
130	dir = opendir(sysfs_hid_path);
131	if (dir == NULL)
132	goto end_probe;
133
134	for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
135	if (dent->d_name[0] == '.')
136	continue;
137	DEBUG("%s: device found %s\n", HID_BUS_NAME, dent->d_name);
138	parse_device(ctx, &entry_list, dent->d_name);
139	}
140
141	end_probe:
142	modalias_cleanup(ctx);
143	if (dir)
144	closedir(dir);
145
146	return entry_list;
147	}
148
149	void hid_entries_free(struct hid_entries *entries)
150	{
151	unsigned int i;
152	for (i = 0; i < entries->nb; i++) {
153	free(entries->entries[i].module);
154	free(entries->entries[i].text);
155	}
156	free(entries->entries);
157	}