aboutsummaryrefslogtreecommitdiff
path: root/modules/devices
diff options
context:
space:
mode:
authorLeandro A. F. Pereira <leandro@hardinfo.org>2010-05-03 09:27:26 -0300
committerLeandro A. F. Pereira <leandro@hardinfo.org>2010-05-03 21:08:06 -0300
commit9273c075a2f993c5154614b70233d8f74515c851 (patch)
treeeb72a8c58e6bc8f4ca3b739d28fbecc269c0052d /modules/devices
parent9a50155ec3e27aa6cedf3f118196f1947c769a29 (diff)
Move files from hardinfo2 to root.
Diffstat (limited to 'modules/devices')
-rw-r--r--modules/devices/battery.c307
-rw-r--r--modules/devices/devmemory.c107
-rw-r--r--modules/devices/dmi.c200
-rw-r--r--modules/devices/inputdevices.c144
-rw-r--r--modules/devices/pci.c245
-rw-r--r--modules/devices/printers.c271
-rw-r--r--modules/devices/resources.c105
-rw-r--r--modules/devices/sensors.c383
-rw-r--r--modules/devices/storage.c377
-rw-r--r--modules/devices/usb.c349
-rw-r--r--modules/devices/x86/processor.c562
11 files changed, 3050 insertions, 0 deletions
diff --git a/modules/devices/battery.c b/modules/devices/battery.c
new file mode 100644
index 00000000..37416dbb
--- /dev/null
+++ b/modules/devices/battery.c
@@ -0,0 +1,307 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include <string.h>
+#include <time.h>
+
+#include "hardinfo.h"
+#include "devices.h"
+
+const struct {
+ gchar *key, *name;
+} ups_fields[] = {
+ { "UPS Status", NULL },
+ { "STATUS", "Status" },
+ { "TIMELEFT", "Time Left" },
+ { "LINEV", "Line Voltage" },
+ { "LOADPCT", "Load Percent" },
+
+ { "UPS Battery Information", NULL },
+ { "BATTV", "Battery Voltage" },
+ { "BCHARGE", "Battery Charge" },
+ { "BATTDATE", "Battery Date" },
+
+ { "UPS Information", NULL },
+ { "APCMODEL", "Model" },
+ { "FIRMWARE", "Firmware Version" },
+ { "SERIALNO", "Serial Number" },
+ { "UPSMODE", "UPS Mode" },
+ { "CABLE", "Cable" },
+ { "UPSNAME", "UPS Name" },
+
+ { "UPS Nominal Values", NULL },
+ { "NOMINV", "Voltage" },
+ { "NOMBATTV", "Battery Voltage" },
+ { "NOMPOWER", "Power" }
+};
+
+
+static void
+__scan_battery_apcupsd(void)
+{
+ GHashTable *ups_data;
+ FILE *apcaccess;
+ char buffer[512], *apcaccess_path;
+ int i;
+
+ apcaccess_path = find_program("apcaccess");
+
+ if ((apcaccess = popen(apcaccess_path, "r"))) {
+ /* first line isn't important */
+ if (fgets(buffer, 512, apcaccess)) {
+ /* allocate the key, value hash table */
+ ups_data = g_hash_table_new(g_str_hash, g_str_equal);
+
+ /* read up all the apcaccess' output, saving it in the key, value hash table */
+ while (fgets(buffer, 512, apcaccess)) {
+ buffer[9] = '\0';
+
+ g_hash_table_insert(ups_data,
+ g_strdup(g_strstrip(buffer)),
+ g_strdup(g_strstrip(buffer + 10)));
+ }
+
+ /* builds the ups info string, respecting the field order as found in ups_fields */
+ for (i = 0; i < G_N_ELEMENTS(ups_fields); i++) {
+ if (!ups_fields[i].name) {
+ /* there's no name: make a group with the key as its name */
+ battery_list = h_strdup_cprintf("[%s]\n", battery_list, ups_fields[i].key);
+ } else {
+ /* there's a name: adds a line */
+ battery_list = h_strdup_cprintf("%s=%s\n", battery_list,
+ ups_fields[i].name,
+ g_hash_table_lookup(ups_data, ups_fields[i].key));
+ }
+ }
+
+ g_hash_table_destroy(ups_data);
+ }
+
+ pclose(apcaccess);
+ }
+
+ g_free(apcaccess_path);
+}
+
+static void
+__scan_battery_acpi(void)
+{
+ gchar *acpi_path;
+
+ gchar *present = NULL;
+ gchar *capacity = NULL;
+ gchar *technology = NULL;
+ gchar *voltage = NULL;
+ gchar *model = NULL, *serial = NULL, *type = NULL;
+ gchar *state = NULL, *rate = NULL;
+ gchar *remaining = NULL;
+ gchar *manufacturer = NULL;
+
+ acpi_path = g_strdup("/proc/acpi/battery");
+ if (g_file_test(acpi_path, G_FILE_TEST_EXISTS)) {
+ GDir *acpi;
+
+ if ((acpi = g_dir_open(acpi_path, 0, NULL))) {
+ const gchar *entry;
+
+ while ((entry = g_dir_read_name(acpi))) {
+ gchar *path = g_strdup_printf("%s/%s/info", acpi_path, entry);
+ FILE *f;
+ gchar buffer[256];
+ gdouble charge_rate = 1.0;
+
+ f = fopen(path, "r");
+ g_free(path);
+
+ if (!f)
+ goto cleanup;
+
+ while (fgets(buffer, 256, f)) {
+ gchar **tmp = g_strsplit(buffer, ":", 2);
+
+ GET_STR("present", present);
+ GET_STR("design capacity", capacity);
+ GET_STR("battery technology", technology);
+ GET_STR("design voltage", voltage);
+ GET_STR("model number", model);
+ GET_STR("serial number", serial);
+ GET_STR("battery type", type);
+ GET_STR("OEM info", manufacturer);
+
+ g_strfreev(tmp);
+ }
+ fclose(f);
+
+ path = g_strdup_printf("%s/%s/state", acpi_path, entry);
+ f = fopen(path, "r");
+ g_free(path);
+
+ if (!f)
+ goto cleanup;
+
+ while (fgets(buffer, 256, f)) {
+ gchar **tmp = g_strsplit(buffer, ":", 2);
+
+ GET_STR("charging state", state);
+ GET_STR("present rate", rate);
+ GET_STR("remaining capacity", remaining);
+
+ g_strfreev(tmp);
+ }
+
+ fclose(f);
+
+ const gchar *url = vendor_get_url(manufacturer);
+ if (url) {
+ char *tmp = g_strdup_printf("%s (%s)", vendor_get_name(manufacturer), url);
+ g_free(manufacturer);
+ manufacturer = tmp;
+ }
+
+ if (g_str_equal(present, "yes")) {
+ charge_rate = atof(remaining) / atof(capacity);
+
+ battery_list = h_strdup_cprintf("\n[Battery: %s]\n"
+ "State=%s (load: %s)\n"
+ "Capacity=%s / %s (%.2f%%)\n"
+ "Battery Technology=%s (%s)\n"
+ "Manufacturer=%s\n"
+ "Model Number=%s\n"
+ "Serial Number=%s\n",
+ battery_list,
+ entry,
+ state, rate,
+ remaining, capacity, charge_rate * 100.0,
+ technology, type,
+ manufacturer,
+ model,
+ serial);
+ }
+
+ cleanup:
+ g_free(present);
+ g_free(capacity);
+ g_free(technology);
+ g_free(type);
+ g_free(model);
+ g_free(serial);
+ g_free(state);
+ g_free(remaining);
+ g_free(rate);
+ g_free(manufacturer);
+
+ present = capacity = technology = type = \
+ model = serial = state = remaining = rate = NULL;
+ }
+
+ g_dir_close(acpi);
+ }
+ }
+
+ g_free(acpi_path);
+}
+
+static void
+__scan_battery_apm(void)
+{
+ FILE *procapm;
+ static char *sremaining = NULL, *stotal = NULL;
+ static unsigned int last_time = 0;
+ static int percentage = 0;
+ const char *ac_status[] = { "Battery",
+ "AC Power",
+ "Charging" };
+ int ac_bat;
+ char apm_bios_ver[16], apm_drv_ver[16];
+ char trash[10];
+
+ if ((procapm = fopen("/proc/apm", "r"))) {
+ int old_percentage = percentage;
+
+ (void)fscanf(procapm, "%s %s %s 0x%x %s %s %d%%",
+ apm_drv_ver, apm_bios_ver, trash,
+ &ac_bat, trash, trash, &percentage);
+ fclose(procapm);
+
+ if (last_time == 0) {
+ last_time = time(NULL);
+ sremaining = stotal = NULL;
+ }
+
+ if (old_percentage - percentage > 0) {
+ if (sremaining && stotal) {
+ g_free(sremaining);
+ g_free(stotal);
+ }
+
+ int secs_remaining = (time(NULL) - last_time) * percentage /
+ (old_percentage - percentage);
+ sremaining = seconds_to_string(secs_remaining);
+ stotal = seconds_to_string((secs_remaining * 100) / percentage);
+
+ last_time = time(NULL);
+ }
+ } else {
+ return;
+ }
+
+ if (stotal && sremaining) {
+ battery_list = h_strdup_cprintf("\n[Battery (APM)]\n"
+ "Charge=%d%%\n"
+ "Remaining Charge=%s of %s\n"
+ "Using=%s\n"
+ "APM driver version=%s\n"
+ "APM BIOS version=%s\n",
+ battery_list,
+ percentage,
+ sremaining, stotal,
+ ac_status[ac_bat],
+ apm_drv_ver, apm_bios_ver);
+ } else {
+ battery_list = h_strdup_cprintf("\n[Battery (APM)]\n"
+ "Charge=%d%%\n"
+ "Using=%s\n"
+ "APM driver version=%s\n"
+ "APM BIOS version=%s\n",
+ battery_list,
+ percentage,
+ ac_status[ac_bat],
+ apm_drv_ver, apm_bios_ver);
+
+ }
+}
+
+void
+scan_battery_do(void)
+{
+ if (battery_list) {
+ g_free(battery_list);
+ }
+ battery_list = g_strdup("");
+
+ __scan_battery_acpi();
+ __scan_battery_apm();
+ __scan_battery_apcupsd();
+
+ if (*battery_list == '\0') {
+ g_free(battery_list);
+
+ battery_list = g_strdup("[No batteries]\n"
+ "No batteries found on this system=\n");
+ }
+}
diff --git a/modules/devices/devmemory.c b/modules/devices/devmemory.c
new file mode 100644
index 00000000..8c89d567
--- /dev/null
+++ b/modules/devices/devmemory.c
@@ -0,0 +1,107 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include <string.h>
+#include "devices.h"
+
+GHashTable *memlabels = NULL;
+
+void scan_memory_do(void)
+{
+ gchar **keys, *tmp;
+ static gint offset = -1;
+ gint i;
+
+ if (offset == -1) {
+ /* gah. linux 2.4 adds three lines of data we don't need in
+ /proc/meminfo */
+ gchar *os_kernel = module_call_method("computer::getOSKernel");
+ if (os_kernel) {
+ offset = strstr(os_kernel, "Linux 2.4") ? 3 : 0;
+ g_free(os_kernel);
+ } else {
+ offset = 0;
+ }
+ }
+
+ g_file_get_contents("/proc/meminfo", &meminfo, NULL, NULL);
+
+ keys = g_strsplit(meminfo, "\n", 0);
+
+ g_free(meminfo);
+ g_free(lginterval);
+
+ meminfo = g_strdup("");
+ lginterval = g_strdup("");
+
+ for (i = offset; keys[i]; i++) {
+ gchar **newkeys = g_strsplit(keys[i], ":", 0);
+
+ if (!newkeys[0]) {
+ g_strfreev(newkeys);
+ break;
+ }
+
+ g_strstrip(newkeys[1]);
+
+ if ((tmp = g_hash_table_lookup(memlabels, newkeys[0]))) {
+ g_free(newkeys[0]);
+ newkeys[0] = g_strdup(tmp);
+ }
+
+ g_hash_table_replace(moreinfo, g_strdup(newkeys[0]), g_strdup(newkeys[1]));
+
+ tmp = g_strconcat(meminfo, newkeys[0], "=", newkeys[1], "\n", NULL);
+ g_free(meminfo);
+ meminfo = tmp;
+
+ tmp = g_strconcat(lginterval,
+ "UpdateInterval$", newkeys[0], "=1000\n", NULL);
+ g_free(lginterval);
+ lginterval = tmp;
+
+ g_strfreev(newkeys);
+ }
+ g_strfreev(keys);
+}
+
+void init_memory_labels(void)
+{
+ static struct {
+ char *proc_label;
+ char *real_label;
+ } proc2real[] = {
+ { "MemTotal", "Total Memory" },
+ { "MemFree", "Free Memory" },
+ { "SwapCached", "Cached Swap" },
+ { "HighTotal", "High Memory" },
+ { "HighFree", "Free High Memory" },
+ { "LowTotal", "Low Memory" },
+ { "LowFree", "Free Low Memory" },
+ { "SwapTotal", "Virtual Memory" },
+ { "SwapFree", "Free Virtual Memory" },
+ { NULL },
+ };
+ gint i;
+
+ memlabels = g_hash_table_new(g_str_hash, g_str_equal);
+
+ for (i = 0; proc2real[i].proc_label; i++) {
+ g_hash_table_insert(memlabels, proc2real[i].proc_label, proc2real[i].real_label);
+ }
+}
diff --git a/modules/devices/dmi.c b/modules/devices/dmi.c
new file mode 100644
index 00000000..8cc45462
--- /dev/null
+++ b/modules/devices/dmi.c
@@ -0,0 +1,200 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+/*
+ * DMI support based on patch by Stewart Adam <s.adam@diffingo.com>
+ */
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "devices.h"
+
+typedef struct _DMIInfo DMIInfo;
+
+struct _DMIInfo {
+ const gchar *name;
+ const gchar *file; /* for sysfs */
+ const gchar *param; /* for dmidecode */
+};
+
+DMIInfo dmi_info_table[] = {
+ { "$BIOS", NULL, NULL },
+ { "Date", "/sys/class/dmi/id/bios_date", "bios-release-date" },
+ { "Vendor", "/sys/class/dmi/id/bios_vendor", "bios-vendor" },
+ { "Version", "/sys/class/dmi/id/bios_version", "bios-version" },
+ { "$Board", NULL, NULL },
+ { "Name", "/sys/class/dmi/id/board_name", "baseboard-product-name" },
+ { "Vendor", "/sys/class/dmi/id/board_vendor", "baseboard-manufacturer" },
+};
+
+gchar *dmi_info = NULL;
+
+gboolean dmi_get_info_dmidecode()
+{
+ FILE *dmi_pipe;
+ gchar buffer[256];
+ DMIInfo *info;
+ gboolean dmi_failed = FALSE;
+ gint i;
+
+ if (dmi_info) {
+ g_free(dmi_info);
+ dmi_info = NULL;
+ }
+
+ for (i = 0; i < G_N_ELEMENTS(dmi_info_table); i++) {
+ info = &dmi_info_table[i];
+
+ if (*(info->name) == '$') {
+ dmi_info = h_strdup_cprintf("[%s]\n", dmi_info,
+ (info->name) + 1);
+ } else {
+ gchar *temp;
+
+ if (!info->param)
+ continue;
+
+ temp = g_strconcat("dmidecode -s ", info->param, NULL);
+ if ((dmi_pipe = popen(temp, "r"))) {
+ g_free(temp);
+
+ (void)fgets(buffer, 256, dmi_pipe);
+ if (pclose(dmi_pipe)) {
+ dmi_failed = TRUE;
+ break;
+ }
+
+ const gchar *url = vendor_get_url(buffer);
+ if (url) {
+ const gchar *vendor = vendor_get_name(buffer);
+ if (g_strstr_len(vendor, -1, g_strstrip(buffer)) ||
+ g_strstr_len(g_strstrip(buffer), -1, vendor)) {
+ dmi_info = h_strdup_cprintf("%s=%s (%s)\n",
+ dmi_info,
+ info->name,
+ g_strstrip(buffer),
+ url);
+ } else {
+ dmi_info = h_strdup_cprintf("%s=%s (%s, %s)\n",
+ dmi_info,
+ info->name,
+ g_strstrip(buffer),
+ vendor, url);
+ }
+ } else {
+ dmi_info = h_strdup_cprintf("%s=%s\n",
+ dmi_info,
+ info->name,
+ buffer);
+ }
+ } else {
+ g_free(temp);
+ dmi_failed = TRUE;
+ break;
+ }
+ }
+ }
+
+ if (dmi_failed) {
+ g_free(dmi_info);
+ dmi_info = NULL;
+ }
+
+ return !dmi_failed;
+}
+
+gboolean dmi_get_info_sys()
+{
+ FILE *dmi_file;
+ gchar buffer[256];
+ DMIInfo *info;
+ gboolean dmi_failed = FALSE;
+ gint i;
+
+ if (dmi_info) {
+ g_free(dmi_info);
+ dmi_info = NULL;
+ }
+
+ for (i = 0; i < G_N_ELEMENTS(dmi_info_table); i++) {
+ info = &dmi_info_table[i];
+
+ if (*(info->name) == '$') {
+ dmi_info = h_strdup_cprintf("[%s]\n", dmi_info,
+ (info->name) + 1);
+ } else {
+ if (!info->file)
+ continue;
+
+ if ((dmi_file = fopen(info->file, "r"))) {
+ (void)fgets(buffer, 256, dmi_file);
+ fclose(dmi_file);
+
+ const gchar *url = vendor_get_url(buffer);
+ if (url) {
+ const gchar *vendor = vendor_get_name(buffer);
+ if (g_strstr_len(vendor, -1, g_strstrip(buffer)) ||
+ g_strstr_len(g_strstrip(buffer), -1, vendor)) {
+ dmi_info = h_strdup_cprintf("%s=%s (%s)\n",
+ dmi_info,
+ info->name,
+ g_strstrip(buffer),
+ url);
+ } else {
+ dmi_info = h_strdup_cprintf("%s=%s (%s, %s)\n",
+ dmi_info,
+ info->name,
+ g_strstrip(buffer),
+ vendor, url);
+ }
+ } else {
+ dmi_info = h_strdup_cprintf("%s=%s\n",
+ dmi_info,
+ info->name,
+ g_strstrip(buffer));
+ }
+ } else {
+ dmi_failed = TRUE;
+ break;
+ }
+ }
+ }
+
+ if (dmi_failed) {
+ g_free(dmi_info);
+ dmi_info = NULL;
+ }
+
+ return !dmi_failed;
+}
+
+void __scan_dmi()
+{
+ gboolean dmi_ok;
+
+ dmi_ok = dmi_get_info_sys();
+
+ if (!dmi_ok) {
+ dmi_ok = dmi_get_info_dmidecode();
+ }
+
+ if (!dmi_ok) {
+ dmi_info = g_strdup("[No DMI information]\n"
+ "There was an error retrieving the information.=\n"
+ "Please try running HardInfo as root.=\n");
+ }
+}
diff --git a/modules/devices/inputdevices.c b/modules/devices/inputdevices.c
new file mode 100644
index 00000000..c280e218
--- /dev/null
+++ b/modules/devices/inputdevices.c
@@ -0,0 +1,144 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include <string.h>
+
+#include "hardinfo.h"
+#include "devices.h"
+
+gchar *input_icons = NULL;
+
+static gboolean
+remove_input_devices(gpointer key, gpointer value, gpointer data)
+{
+ return g_str_has_prefix(key, "INP");
+}
+
+static struct {
+ char *name;
+ char *icon;
+} input_devices[] = {
+ { "Keyboard", "keyboard.png" },
+ { "Joystick", "joystick.png" },
+ { "Mouse", "mouse.png" },
+ { "Speaker", "audio.png" },
+ { "Unknown", "module.png" },
+};
+
+void
+__scan_input_devices(void)
+{
+ FILE *dev;
+ gchar buffer[128];
+ gchar *tmp, *name = NULL, *phys = NULL;
+ gint bus, vendor, product, version;
+ int d = 0, n = 0;
+
+ dev = fopen("/proc/bus/input/devices", "r");
+ if (!dev)
+ return;
+
+ if (input_list) {
+ g_hash_table_foreach_remove(moreinfo, remove_input_devices, NULL);
+ g_free(input_list);
+ g_free(input_icons);
+ }
+ input_list = g_strdup("");
+ input_icons = g_strdup("");
+
+ while (fgets(buffer, 128, dev)) {
+ tmp = buffer;
+
+ switch (*tmp) {
+ case 'N':
+ name = g_strdup(tmp + strlen("N: Name="));
+ remove_quotes(name);
+ break;
+ case 'P':
+ phys = g_strdup(tmp + strlen("P: Phys="));
+ break;
+ case 'I':
+ sscanf(tmp, "I: Bus=%x Vendor=%x Product=%x Version=%x",
+ &bus, &vendor, &product, &version);
+ break;
+ case 'H':
+ if (strstr(tmp, "kbd"))
+ d = 0; //INPUT_KEYBOARD;
+ else if (strstr(tmp, "js"))
+ d = 1; //INPUT_JOYSTICK;
+ else if (strstr(tmp, "mouse"))
+ d = 2; //INPUT_MOUSE;
+ else
+ d = 4; //INPUT_UNKNOWN;
+ break;
+ case '\n':
+ if (strstr(name, "PC Speaker")) {
+ d = 3; // INPUT_PCSPKR
+ }
+
+ tmp = g_strdup_printf("INP%d", ++n);
+ input_list = h_strdup_cprintf("$%s$%s=\n",
+ input_list,
+ tmp, name);
+ input_icons = h_strdup_cprintf("Icon$%s$%s=%s\n",
+ input_icons,
+ tmp, name,
+ input_devices[d].icon);
+ gchar *strhash = g_strdup_printf("[Device Information]\n"
+ "Name=%s\n"
+ "Type=%s\n"
+ "Bus=0x%x\n",
+ name,
+ input_devices[d].name,
+ bus);
+
+ const gchar *url = vendor_get_url(name);
+ if (url) {
+ strhash = h_strdup_cprintf("Vendor=%s (%s)\n",
+ strhash,
+ vendor_get_name(name),
+ url);
+ } else {
+ strhash = h_strdup_cprintf("Vendor=%x\n",
+ strhash,
+ vendor);
+ }
+
+ strhash = h_strdup_cprintf("Product=0x%x\n"
+ "Version=0x%x\n",
+ strhash, product, version);
+
+ if (phys[1] != 0) {
+ strhash = h_strdup_cprintf("Connected to=%s\n",
+ strhash, phys);
+ }
+
+ if (strstr(phys,"ir")) {
+ strhash = h_strdup_cprintf("InfraRed port=yes\n",
+ strhash);
+ }
+
+ g_hash_table_insert(moreinfo, tmp, strhash);
+
+ g_free(phys);
+ g_free(name);
+ }
+ }
+
+ fclose(dev);
+}
diff --git a/modules/devices/pci.c b/modules/devices/pci.c
new file mode 100644
index 00000000..a8439019
--- /dev/null
+++ b/modules/devices/pci.c
@@ -0,0 +1,245 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+/*
+ * TODO: This thing must be rewritten. We really should have a struct with all the
+ * PCI stuff we'll present to the user, and hash them by the PCI ID
+ * (domain:bus:device.function).
+ * This way we'll have ways to better organize the output, instead of relying
+ * on the order the information appears on lspci's output.
+ * Also, the "Resources" thing might be better implemented (and we won't need
+ * copies of information scattered everywhere like we do today).
+ */
+
+#include <string.h>
+
+#include "hardinfo.h"
+#include "devices.h"
+
+GHashTable *_pci_devices = NULL;
+
+void
+scan_pci_do(void)
+{
+ FILE *lspci;
+ gchar buffer[256], *buf, *strhash = NULL, *strdevice = NULL;
+ gchar *category = NULL, *name = NULL, *icon, *lspci_path, *command_line = NULL;
+ gint n = 0, x = 0;
+
+ if ((lspci_path = find_program("lspci")) == NULL) {
+ goto pci_error;
+ } else {
+ command_line = g_strdup_printf("%s -v", lspci_path);
+ }
+
+ if (!_pci_devices) {
+ _pci_devices = g_hash_table_new(g_str_hash, g_str_equal);
+ }
+
+ buf = g_build_filename(g_get_home_dir(), ".hardinfo", "pci.ids", NULL);
+ if (!g_file_test(buf, G_FILE_TEST_EXISTS)) {
+ DEBUG("using system-provided PCI IDs");
+ g_free(buf);
+ if (!(lspci = popen(command_line, "r"))) {
+ goto pci_error;
+ }
+ } else {
+ gchar *tmp;
+
+ tmp = g_strdup_printf("%s -i '%s'", command_line, buf);
+ g_free(buf);
+ buf = tmp;
+
+ DEBUG("using updated PCI IDs (from %s)", buf);
+ if (!(lspci = popen(tmp, "r"))) {
+ g_free(buf);
+ goto pci_error;
+ } else {
+ g_free(buf);
+ }
+ }
+
+ while (fgets(buffer, 256, lspci)) {
+ buf = g_strstrip(buffer);
+
+ if (!strncmp(buf, "Flags", 5)) {
+ gint irq = 0, freq = 0, latency = 0, i;
+ gchar **list;
+ gboolean bus_master;
+
+ buf += 7;
+
+ bus_master = FALSE;
+
+ list = g_strsplit(buf, ", ", 10);
+ for (i = 0; i <= 10; i++) {
+ if (!list[i])
+ break;
+
+ if (!strncmp(list[i], "IRQ", 3))
+ sscanf(list[i], "IRQ %d", &irq);
+ else if (strstr(list[i], "Mhz"))
+ sscanf(list[i], "%dMhz", &freq);
+ else if (!strncmp(list[i], "bus master", 10))
+ bus_master = TRUE;
+ else if (!strncmp(list[i], "latency", 7))
+ sscanf(list[i], "latency %d", &latency);
+ }
+ g_strfreev(list);
+
+ if (irq)
+ strdevice = h_strdup_cprintf("IRQ=%d\n", strdevice, irq);
+ if (freq)
+ strdevice = h_strdup_cprintf("Frequency=%dMHz\n", strdevice, freq);
+ if (latency)
+ strdevice = h_strdup_cprintf("Latency=%d\n", strdevice, latency);
+
+ strdevice = h_strdup_cprintf("Bus Master=%s\n", strdevice, bus_master ? "Yes" : "No");
+ } else if (!strncmp(buf, "Kernel modules", 14)) {
+ WALK_UNTIL(' ');
+ WALK_UNTIL(':');
+ buf++;
+
+ strdevice = h_strdup_cprintf("Kernel modules=%s\n", strdevice, buf);
+ } else if (!strncmp(buf, "Subsystem", 9)) {
+ WALK_UNTIL(' ');
+ buf++;
+ const gchar *oem_vendor_url = vendor_get_url(buf);
+ if (oem_vendor_url)
+ strdevice = h_strdup_cprintf("OEM Vendor=%s (%s)\n",
+ strdevice,
+ vendor_get_name(buf),
+ oem_vendor_url);
+ } else if (!strncmp(buf, "Capabilities", 12)
+ && !strstr(buf, "only to root") &&
+ !strstr(buf, "access denied")) {
+ WALK_UNTIL(' ');
+ WALK_UNTIL(']');
+ buf++;
+ strdevice = h_strdup_cprintf("Capability#%d=%s\n", strdevice, ++x, buf);
+ } else if (!strncmp(buf, "Memory at", 9) && strstr(buf, "[size=")) {
+ gint mem;
+ gchar unit;
+ gboolean prefetch;
+ gboolean _32bit;
+
+ prefetch = strstr(buf, "non-prefetchable") ? FALSE : TRUE;
+ _32bit = strstr(buf, "32-bit") ? TRUE : FALSE;
+
+ WALK_UNTIL('[');
+ sscanf(buf, "[size=%d%c", &mem, &unit);
+
+ strdevice = h_strdup_cprintf("Memory#%d=%d%cB (%s%s)\n",
+ strdevice, ++x,
+ mem,
+ (unit == ']') ? ' ' : unit,
+ _32bit ? "32-bit, " : "",
+ prefetch ? "prefetchable" :
+ "non-prefetchable");
+
+ } else if (!strncmp(buf, "I/O ports at", 12)) {
+ guint io_addr, io_size;
+
+ sscanf(buf, "I/O ports at %x [size=%d]", &io_addr, &io_size);
+
+ strdevice =
+ h_strdup_cprintf("I/O ports at#%d=0x%x - 0x%x\n",
+ strdevice, ++x, io_addr,
+ io_addr + io_size - 1);
+ } else if ((buf[0] >= '0' && buf[0] <= '9') && (buf[4] == ':' || buf[2] == ':')) {
+ gint bus, device, function, domain;
+ gpointer start, end;
+
+ if (strdevice != NULL && strhash != NULL) {
+ g_hash_table_insert(moreinfo, strhash, strdevice);
+ g_free(category);
+ g_free(name);
+ }
+
+ if (buf[4] == ':') {
+ sscanf(buf, "%x:%x:%x.%d", &domain, &bus, &device, &function);
+ } else {
+ /* lspci without domain field */
+ sscanf(buf, "%x:%x.%x", &bus, &device, &function);
+ domain = 0;
+ }
+
+ WALK_UNTIL(' ');
+
+ start = buf;
+
+ WALK_UNTIL(':');
+ end = buf + 1;
+ *buf = 0;
+
+ buf = start + 1;
+ category = g_strdup(buf);
+
+ buf = end;
+
+ if (strstr(category, "RAM memory")) icon = "mem";
+ else if (strstr(category, "Multimedia")) icon = "media";
+ else if (strstr(category, "USB")) icon = "usb";
+ else icon = "pci";
+
+ name = g_strdup(buf);
+ g_hash_table_insert(_pci_devices,
+ g_strdup_printf("0000:%02x:%02x.%x", bus, device, function),
+ name);
+
+ strhash = g_strdup_printf("PCI%d", n);
+ strdevice = g_strdup_printf("[Device Information]\n"
+ "Name=%s\n"
+ "Class=%s\n"
+ "Domain=%d\n"
+ "Bus, device, function=%d, %d, %d\n",
+ name, category, domain, bus,
+ device, function);
+
+ const gchar *url = vendor_get_url(name);
+ if (url) {
+ strdevice = h_strdup_cprintf("Vendor=%s (%s)\n",
+ strdevice,
+ vendor_get_name(name),
+ url);
+ }
+
+ g_hash_table_insert(_pci_devices,
+ g_strdup_printf("0000:%02x:%02x.%x", bus, device, function),
+ g_strdup(name));
+
+ pci_list = h_strdup_cprintf("$PCI%d$%s=%s\n", pci_list, n, category, name);
+
+ n++;
+ }
+ }
+
+ if (pclose(lspci)) {
+pci_error:
+ /* error (no pci, perhaps?) */
+ pci_list = g_strconcat(pci_list, "No PCI devices found=\n", NULL);
+ } else if (strhash) {
+ /* insert the last device */
+ g_hash_table_insert(moreinfo, strhash, strdevice);
+ g_free(category);
+ g_free(name);
+ }
+
+ g_free(lspci_path);
+ g_free(command_line);
+}
diff --git a/modules/devices/printers.c b/modules/devices/printers.c
new file mode 100644
index 00000000..80851a00
--- /dev/null
+++ b/modules/devices/printers.c
@@ -0,0 +1,271 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2007 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "devices.h"
+
+typedef struct _CUPSDest CUPSDest;
+typedef struct _CUPSOption CUPSOption;
+
+struct _CUPSOption {
+ char *name, *value;
+};
+
+struct _CUPSDest {
+ char *name, *instance;
+ int is_default;
+ int num_options;
+ CUPSOption *options;
+};
+
+static int (*cups_dests_get) (CUPSDest **dests) = NULL;
+static int (*cups_dests_free) (int num_dests, CUPSDest *dests) = NULL;
+static gboolean cups_init = FALSE;
+
+GModule *cups;
+
+static gboolean
+remove_printer_devices(gpointer key, gpointer value, gpointer data)
+{
+ return g_str_has_prefix(key, "PRN");
+}
+
+void
+init_cups(void)
+{
+ const char *libcups[] = { "libcups", "libcups.so", "libcups.so.1", "libcups.so.2", NULL };
+
+ if (!(cups_dests_get && cups_dests_free)) {
+ int i;
+
+ for (i = 0; libcups[i] != NULL; i++) {
+ cups = g_module_open(libcups[i], G_MODULE_BIND_LAZY);
+ if (cups)
+ break;
+ }
+
+ if (!cups) {
+ cups_init = FALSE;
+ return;
+ }
+
+ if (!g_module_symbol(cups, "cupsGetDests", (gpointer) & cups_dests_get)
+ || !g_module_symbol(cups, "cupsFreeDests", (gpointer) & cups_dests_free)) {
+ g_module_close(cups);
+ cups_init = FALSE;
+ }
+ }
+
+ cups_init = TRUE;
+}
+
+gchar *__cups_callback_ptype(gchar *strvalue)
+{
+ if (strvalue) {
+ unsigned value = atoi(strvalue);
+ gchar *output = g_strdup("\n");
+
+ if (value & 0x0004)
+ output = h_strdup_cprintf("\342\232\254 Can do black and white printing=\n", output);
+ if (value & 0x0008)
+ output = h_strdup_cprintf("\342\232\254 Can do color printing=\n", output);
+ if (value & 0x0010)
+ output = h_strdup_cprintf("\342\232\254 Can do duplexing=\n", output);
+ if (value & 0x0020)
+ output = h_strdup_cprintf("\342\232\254 Can do staple output=\n", output);
+ if (value & 0x0040)
+ output = h_strdup_cprintf("\342\232\254 Can do copies=\n", output);
+ if (value & 0x0080)
+ output = h_strdup_cprintf("\342\232\254 Can collate copies=\n", output);
+ if (value & 0x80000)
+ output = h_strdup_cprintf("\342\232\254 Printer is rejecting jobs=\n", output);
+ if (value & 0x1000000)
+ output = h_strdup_cprintf("\342\232\254 Printer was automatically discovered and added=\n", output);
+
+ return output;
+ } else {
+ return g_strdup("Unknown");
+ }
+}
+
+gchar *__cups_callback_state(gchar *value)
+{
+ if (!value) {
+ return g_strdup("Unknown");
+ }
+
+ if (g_str_equal(value, "3")) {
+ return g_strdup("Idle");
+ } else if (g_str_equal(value, "4")) {
+ return g_strdup("Printing a Job");
+ } else if (g_str_equal(value, "5")) {
+ return g_strdup("Stopped");
+ } else {
+ return g_strdup("Unknown");
+ }
+}
+
+gchar *__cups_callback_state_change_time(gchar *value)
+{
+ struct tm tm;
+ char buf[255];
+
+ if (value) {
+ strptime(value, "%s", &tm);
+ strftime(buf, sizeof(buf), "%c", &tm);
+
+ return g_strdup(buf);
+ } else {
+ return g_strdup("Unknown");
+ }
+}
+
+gchar *__cups_callback_boolean(gchar *value)
+{
+ if (value) {
+ return g_strdup(g_str_equal(value, "1") ? "Yes" : "No");
+ } else {
+ return g_strdup("Unknown");
+ }
+}
+
+const struct {
+ char *key, *name;
+ gchar *(*callback)(gchar *value);
+} cups_fields[] = {
+ { "Printer Information", NULL, NULL },
+ { "printer-info", "Destination Name", NULL },
+ { "printer-make-and-model", "Make and Model", NULL },
+
+ { "Capabilities", NULL, NULL },
+ { "printer-type", "#", __cups_callback_ptype },
+
+ { "Printer State", NULL, NULL },
+ { "printer-state", "State", __cups_callback_state },
+ { "printer-state-change-time", "Change Time", __cups_callback_state_change_time },
+ { "printer-state-reasons", "State Reasons" },
+
+ { "Sharing Information", NULL, NULL },
+ { "printer-is-shared", "Shared?", __cups_callback_boolean },
+ { "printer-location", "Physical Location" },
+ { "auth-info-required", "Authentication Required", __cups_callback_boolean },
+
+ { "Jobs", NULL, NULL },
+ { "job-hold-until", "Hold Until", NULL },
+ { "job-priority", "Priority", NULL },
+ { "printer-is-accepting-jobs", "Accepting Jobs", __cups_callback_boolean },
+
+ { "Media", NULL, NULL },
+ { "media", "Media", NULL },
+ { "finishings", "Finishings", NULL },
+ { "copies", "Copies", NULL },
+};
+
+void
+scan_printers_do(void)
+{
+ int num_dests, i, j;
+ CUPSDest *dests;
+ gchar *prn_id, *prn_moreinfo;
+
+ g_free(printer_list);
+ g_free(printer_icons);
+
+ if (!cups_init) {
+ __init_cups();
+
+ printer_icons = g_strdup("");
+ printer_list = g_strdup("[Printers]\n"
+ "No suitable CUPS library found=");
+ return;
+ }
+
+ /* remove old devices from global device table */
+ g_hash_table_foreach_remove(moreinfo, remove_printer_devices, NULL);
+
+ num_dests = cups_dests_get(&dests);
+ if (num_dests > 0) {
+ printer_list = g_strdup_printf("[Printers (CUPS)]\n");
+ printer_icons = g_strdup("");
+ for (i = 0; i < num_dests; i++) {
+ GHashTable *options;
+
+ options = g_hash_table_new(g_str_hash, g_str_equal);
+
+ for (j = 0; j < dests[i].num_options; j++) {
+ g_hash_table_insert(options,
+ g_strdup(dests[i].options[j].name),
+ g_strdup(dests[i].options[j].value));
+ }
+
+ prn_id = g_strdup_printf("PRN%d", i);
+
+ printer_list = h_strdup_cprintf("\n$%s$%s=%s\n",
+ printer_list,
+ prn_id,
+ dests[i].name,
+ dests[i].is_default ? "<i>Default</i>" : "");
+ printer_icons = h_strdup_cprintf("\nIcon$%s$%s=printer.png",
+ printer_icons,
+ prn_id,
+ dests[i].name);
+
+ prn_moreinfo = g_strdup("");
+ for (j = 0; j < G_N_ELEMENTS(cups_fields); j++) {
+ if (!cups_fields[j].name) {
+ prn_moreinfo = h_strdup_cprintf("[%s]\n",
+ prn_moreinfo,
+ cups_fields[j].key);
+ } else {
+ gchar *temp;
+
+ temp = g_hash_table_lookup(options, cups_fields[j].key);
+
+ if (cups_fields[j].callback) {
+ temp = cups_fields[j].callback(temp);
+ } else {
+ if (temp) {
+ /* FIXME Do proper escaping */
+ temp = g_strdup(strreplacechr(temp, "&=", ' '));
+ } else {
+ temp = g_strdup("Unknown");
+ }
+ }
+
+ prn_moreinfo = h_strdup_cprintf("%s=%s\n",
+ prn_moreinfo,
+ cups_fields[j].name,
+ temp);
+
+ g_free(temp);
+ }
+ }
+
+ g_hash_table_insert(moreinfo, prn_id, prn_moreinfo);
+ g_hash_table_destroy(options);
+ }
+
+ cups_dests_free(num_dests, dests);
+ } else {
+ printer_list = g_strdup("[Printers]\n"
+ "No printers found=\n");
+ }
+}
diff --git a/modules/devices/resources.c b/modules/devices/resources.c
new file mode 100644
index 00000000..270000dd
--- /dev/null
+++ b/modules/devices/resources.c
@@ -0,0 +1,105 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2008 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include "devices.h"
+
+gchar *_resources = NULL;
+
+#if GLIB_CHECK_VERSION(2,14,0)
+static GRegex *_regex_pci = NULL,
+ *_regex_module = NULL;
+
+static gchar *_resource_obtain_name(gchar *name)
+{
+ gchar *temp;
+
+ if (!_regex_pci && !_regex_module) {
+ _regex_pci = g_regex_new("^[0-9a-fA-F]{4}:[0-9a-fA-F]{2}:"
+ "[0-9a-fA-F]{2}\\.[0-9a-fA-F]{1}$",
+ 0, 0, NULL);
+ _regex_module = g_regex_new("^[0-9a-zA-Z\\_\\-]+$", 0, 0, NULL);
+ }
+
+ name = g_strstrip(name);
+
+ if (g_regex_match(_regex_pci, name, 0, NULL)) {
+ temp = module_call_method_param("devices::getPCIDeviceDescription", name);
+ if (temp) {
+ return g_strdup_printf("<b><small>PCI</small></b> %s", (gchar *)idle_free(temp));
+ }
+ } else if (g_regex_match(_regex_module, name, 0, NULL)) {
+ temp = module_call_method_param("computer::getKernelModuleDescription", name);
+ if (temp) {
+ return g_strdup_printf("<b><small>Module</small></b> %s", (gchar *)idle_free(temp));
+ }
+ }
+
+ return g_strdup(name);
+}
+#else
+static gchar *_resource_obtain_name(gchar *name)
+{
+ return g_strdup(name);
+}
+#endif
+
+void scan_device_resources(gboolean reload)
+{
+ SCAN_START();
+ FILE *io;
+ gchar buffer[256];
+ gint i;
+
+ struct {
+ gchar *file;
+ gchar *description;
+ } resources[] = {
+ { "/proc/ioports", "[I/O Ports]\n" },
+ { "/proc/iomem", "[Memory]\n" },
+ { "/proc/dma", "[DMA]\n" }
+ };
+
+ g_free(_resources);
+ _resources = g_strdup("");
+
+ for (i = 0; i < G_N_ELEMENTS(resources); i++) {
+ if ((io = fopen(resources[i].file, "r"))) {
+ _resources = h_strconcat(_resources, resources[i].description, NULL);
+
+ while (fgets(buffer, 256, io)) {
+ gchar **temp = g_strsplit(buffer, ":", 2);
+ gchar *name = _resource_obtain_name(temp[1]);
+
+ _resources = h_strdup_cprintf("<tt>%s</tt>=%s\n", _resources,
+ temp[0], name);
+
+ g_strfreev(temp);
+ g_free(name);
+ }
+
+ fclose(io);
+ }
+ }
+
+ SCAN_END();
+}
+
+gchar *callback_device_resources(void)
+{
+ return g_strdup(_resources);
+}
diff --git a/modules/devices/sensors.c b/modules/devices/sensors.c
new file mode 100644
index 00000000..9f02566d
--- /dev/null
+++ b/modules/devices/sensors.c
@@ -0,0 +1,383 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include <string.h>
+
+#include "devices.h"
+#include "expr.h"
+#include "hardinfo.h"
+#include "socket.h"
+
+gchar *sensors = NULL;
+GHashTable *sensor_compute = NULL;
+GHashTable *sensor_labels = NULL;
+
+static void read_sensor_labels(gchar * driver)
+{
+ FILE *conf;
+ gchar buf[256], *line, *p;
+ gboolean lock = FALSE;
+ gint i;
+
+ sensor_labels = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+ sensor_compute = g_hash_table_new(g_str_hash, g_str_equal);
+
+ /* Try to open lm-sensors config file sensors3.conf */
+ conf = fopen("/etc/sensors3.conf", "r");
+
+ /* If it fails, try to open sensors.conf */
+ if (!conf) conf = fopen("/etc/sensors.conf", "r");
+
+ if (!conf) {
+ /* Cannot open config file. */
+ return;
+ }
+
+ while (fgets(buf, 256, conf)) {
+ line = buf;
+
+ remove_linefeed(line);
+ strend(line, '#');
+
+ if (*line == '\0') {
+ continue;
+ } else if (lock && strstr(line, "label")) { /* label lines */
+ gchar **names = g_strsplit(strstr(line, "label") + 5, " ", 0);
+ gchar *name = NULL, *value = NULL;
+
+ for (i = 0; names[i]; i++) {
+ if (names[i][0] == '\0')
+ continue;
+
+ if (!name)
+ name = g_strdup(names[i]);
+ else if (!value)
+ value = g_strdup(names[i]);
+ else
+ value = g_strconcat(value, " ", names[i], NULL);
+ }
+
+ remove_quotes(value);
+ g_hash_table_insert(sensor_labels, name, value);
+
+ g_strfreev(names);
+ } else if (lock && strstr(line, "ignore")) { /* ignore lines */
+ p = strstr(line, "ignore") + 6;
+ if (!strchr(p, ' '))
+ continue;
+
+ while (*p == ' ')
+ p++;
+ g_hash_table_insert(sensor_labels, g_strdup(p), "ignore");
+ } else if (lock && strstr(line, "compute")) { /* compute lines */
+ gchar **formulas =
+ g_strsplit(strstr(line, "compute") + 7, " ", 0);
+ gchar *name = NULL, *formula = NULL;
+
+ for (i = 0; formulas[i]; i++) {
+ if (formulas[i][0] == '\0')
+ continue;
+ if (formulas[i][0] == ',')
+ break;
+
+ if (!name)
+ name = g_strdup(formulas[i]);
+ else if (!formula)
+ formula = g_strdup(formulas[i]);
+ else
+ formula = g_strconcat(formula, formulas[i], NULL);
+ }
+
+ g_strfreev(formulas);
+ g_hash_table_insert(sensor_compute, name,
+ math_string_to_postfix(formula));
+ } else if (g_str_has_prefix(line, "chip")) { /* chip lines (delimiter) */
+ if (lock == FALSE) {
+ gchar **chips = g_strsplit(line, " ", 0);
+
+ for (i = 1; chips[i]; i++) {
+ strend(chips[i], '*');
+
+ if (g_str_has_prefix(chips[i] + 1, driver)) {
+ lock = TRUE;
+ break;
+ }
+ }
+
+ g_strfreev(chips);
+ } else {
+ break;
+ }
+ }
+ }
+
+ fclose(conf);
+}
+
+static gchar *get_sensor_label(gchar * sensor)
+{
+ gchar *ret;
+
+ ret = g_hash_table_lookup(sensor_labels, sensor);
+ if (!ret)
+ ret = g_strdup(sensor);
+ else
+ ret = g_strdup(ret);
+
+ return ret;
+}
+
+static float adjust_sensor(gchar * name, float value)
+{
+ GSList *postfix;
+
+ postfix = g_hash_table_lookup(sensor_compute, name);
+ if (!postfix)
+ return value;
+
+ return math_postfix_eval(postfix, value);
+}
+
+
+static void read_sensors_hwmon(void)
+{
+ int hwmon, count;
+ gchar *path_hwmon, *path_sensor, *tmp, *driver, *name, *mon;
+ hwmon = 0;
+
+ path_hwmon = g_strdup_printf("/sys/class/hwmon/hwmon%d/device/", hwmon);
+ while (g_file_test(path_hwmon, G_FILE_TEST_EXISTS)) {
+ tmp = g_strdup_printf("%sdriver", path_hwmon);
+ driver = g_file_read_link(tmp, NULL);
+ g_free(tmp);
+
+ tmp = g_path_get_basename(driver);
+ g_free(driver);
+ driver = tmp;
+
+ if (!sensor_labels) {
+ read_sensor_labels(driver);
+ }
+
+ sensors = g_strconcat(sensors, "[Cooling Fans]\n", NULL);
+ for (count = 1;; count++) {
+ path_sensor =
+ g_strdup_printf("%sfan%d_input", path_hwmon, count);
+ if (!g_file_get_contents(path_sensor, &tmp, NULL, NULL)) {
+ g_free(path_sensor);
+ break;
+ }
+
+ mon = g_strdup_printf("fan%d", count);
+ name = get_sensor_label(mon);
+ if (!g_str_equal(name, "ignore")) {
+ sensors = h_strdup_cprintf("%s=%.0fRPM\n",
+ sensors, name,
+ adjust_sensor(mon, atof(tmp)));
+ }
+
+ g_free(name);
+ g_free(mon);
+ g_free(tmp);
+ g_free(path_sensor);
+ }
+
+ sensors = g_strconcat(sensors, "[Temperatures]\n", NULL);
+ for (count = 1;; count++) {
+ path_sensor =
+ g_strdup_printf("%stemp%d_input", path_hwmon, count);
+ if (!g_file_get_contents(path_sensor, &tmp, NULL, NULL)) {
+ g_free(path_sensor);
+ break;
+ }
+
+ mon = g_strdup_printf("temp%d", count);
+ name = get_sensor_label(mon);
+ if (!g_str_equal(name, "ignore")) {
+ sensors = h_strdup_cprintf("%s=%.2f\302\260C\n",
+ sensors, name,
+ adjust_sensor(mon,
+ atof(tmp) /
+ 1000.0));
+ }
+
+ g_free(tmp);
+ g_free(name);
+ g_free(path_sensor);
+ g_free(mon);
+ }
+
+ sensors = g_strconcat(sensors, "[Voltage Values]\n", NULL);
+ for (count = 0;; count++) {
+ path_sensor =
+ g_strdup_printf("%sin%d_input", path_hwmon, count);
+ if (!g_file_get_contents(path_sensor, &tmp, NULL, NULL)) {
+ g_free(path_sensor);
+ break;
+ }
+
+
+ mon = g_strdup_printf("in%d", count);
+ name = get_sensor_label(mon);
+ if (!g_str_equal(name, "ignore")) {
+ sensors = h_strdup_cprintf("%s=%.3fV\n",
+ sensors, name,
+ adjust_sensor(mon,
+ atof(tmp) /
+ 1000.0));
+ }
+
+ g_free(tmp);
+ g_free(mon);
+ g_free(name);
+ g_free(path_sensor);
+ }
+
+ g_free(path_hwmon);
+ g_free(driver);
+ path_hwmon =
+ g_strdup_printf("/sys/class/hwmon/hwmon%d/device/", ++hwmon);
+ }
+
+ g_free(path_hwmon);
+
+}
+
+static void read_sensors_acpi(void)
+{
+ const gchar *path_tz = "/proc/acpi/thermal_zone";
+
+ if (g_file_test(path_tz, G_FILE_TEST_EXISTS)) {
+ GDir *tz;
+
+ if ((tz = g_dir_open(path_tz, 0, NULL))) {
+ const gchar *entry;
+ gchar *temp = g_strdup("");
+
+ while ((entry = g_dir_read_name(tz))) {
+ gchar *path =
+ g_strdup_printf("%s/%s/temperature", path_tz, entry);
+ gchar *contents;
+
+ if (g_file_get_contents(path, &contents, NULL, NULL)) {
+ int temperature;
+
+ sscanf(contents, "temperature: %d C", &temperature);
+
+ temp = h_strdup_cprintf("\n%s=%d\302\260C\n",
+ temp, entry, temperature);
+
+ g_free(contents);
+ }
+ }
+
+ if (*temp != '\0')
+ sensors =
+ h_strdup_cprintf("\n[ACPI Thermal Zone]\n%s",
+ sensors, temp);
+
+ g_dir_close(tz);
+ }
+ }
+
+}
+
+static void read_sensors_omnibook(void)
+{
+ const gchar *path_ob = "/proc/omnibook/temperature";
+ gchar *contents;
+
+ if (g_file_get_contents(path_ob, &contents, NULL, NULL)) {
+ int temperature;
+
+ sscanf(contents, "CPU temperature: %d C", &temperature);
+
+ sensors = h_strdup_cprintf("\n[Omnibook]\n"
+ "CPU temperature=%d\302\260C\n",
+ sensors, temperature);
+
+ g_free(contents);
+ }
+}
+
+static void read_sensors_hddtemp(void)
+{
+ Socket *s;
+ static gchar *old = NULL;
+ gchar buffer[1024];
+ gint len = 0;
+
+ if ((s = sock_connect("127.0.0.1", 7634))) {
+ while (!len)
+ len = sock_read(s, buffer, sizeof(buffer));
+ sock_close(s);
+
+ if (len > 2 && buffer[0] == '|' && buffer[1] == '/') {
+ gchar **disks;
+ int i;
+
+ if (old)
+ g_free(old);
+
+ old = g_strdup("[Hard Disk Temperature]\n");
+
+ disks = g_strsplit(buffer, "\n", 0);
+ for (i = 0; disks[i]; i++) {
+ gchar **fields = g_strsplit(disks[i] + 1, "|", 5);
+
+ /*
+ * 0 -> /dev/hda
+ * 1 -> FUJITSU MHV2080AH
+ * 2 -> 41
+ * 3 -> C
+ */
+ old = h_strdup_cprintf("\n%s (%s)=%s\302\260%s\n",
+ old,
+ fields[1], fields[0],
+ fields[2], fields[3]);
+
+ g_strfreev(fields);
+ }
+
+ g_strfreev(disks);
+ }
+ } else {
+ g_free(old);
+ old = NULL;
+ }
+
+ if (old) {
+ sensors = g_strconcat(sensors, "\n", old, NULL);
+ }
+}
+
+void scan_sensors_do(void)
+{
+ if (sensors)
+ g_free(sensors);
+
+ sensors = g_strdup("");
+
+ read_sensors_hwmon();
+ read_sensors_acpi();
+ read_sensors_omnibook();
+ read_sensors_hddtemp();
+
+ /* FIXME: Add support for ibm acpi and more sensors */
+}
diff --git a/modules/devices/storage.c b/modules/devices/storage.c
new file mode 100644
index 00000000..23ab1de2
--- /dev/null
+++ b/modules/devices/storage.c
@@ -0,0 +1,377 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+
+#include <string.h>
+
+#include "hardinfo.h"
+#include "devices.h"
+
+gchar *storage_icons = NULL;
+
+static gboolean
+remove_scsi_devices(gpointer key, gpointer value, gpointer data)
+{
+ return g_str_has_prefix(key, "SCSI");
+}
+
+/* SCSI support by Pascal F.Martin <pascalmartin@earthlink.net> */
+void
+__scan_scsi_devices(void)
+{
+ FILE *proc_scsi;
+ gchar buffer[256], *buf;
+ gint n = 0;
+ gint scsi_controller;
+ gint scsi_channel;
+ gint scsi_id;
+ gint scsi_lun;
+ gchar *vendor = NULL, *revision = NULL, *model = NULL;
+ gchar *scsi_storage_list;
+
+ /* remove old devices from global device table */
+ g_hash_table_foreach_remove(moreinfo, remove_scsi_devices, NULL);
+
+ if (!g_file_test("/proc/scsi/scsi", G_FILE_TEST_EXISTS))
+ return;
+
+ scsi_storage_list = g_strdup("\n[SCSI Disks]\n");
+
+ if ((proc_scsi = fopen("/proc/scsi/scsi", "r"))) {
+ while (fgets(buffer, 256, proc_scsi)) {
+ buf = g_strstrip(buffer);
+ if (!strncmp(buf, "Host: scsi", 10)) {
+ sscanf(buf,
+ "Host: scsi%d Channel: %d Id: %d Lun: %d",
+ &scsi_controller, &scsi_channel, &scsi_id, &scsi_lun);
+
+ n++;
+ } else if (!strncmp(buf, "Vendor: ", 8)) {
+ buf[17] = '\0';
+ buf[41] = '\0';
+ buf[53] = '\0';
+
+ vendor = g_strdup(g_strstrip(buf + 8));
+ model = g_strdup_printf("%s %s", vendor, g_strstrip(buf + 24));
+ revision = g_strdup(g_strstrip(buf + 46));
+ } else if (!strncmp(buf, "Type: ", 8)) {
+ char *p;
+ gchar *type = NULL, *icon = NULL;
+
+ if (!(p = strstr(buf, "ANSI SCSI revision"))) {
+ p = strstr(buf, "ANSI SCSI revision");
+ }
+
+ if (p != NULL) {
+ while (*(--p) == ' ');
+ *(++p) = 0;
+
+ static struct {
+ char *type;
+ char *label;
+ char *icon;
+ } type2icon[] = {
+ { "Direct-Access", "Disk", "hdd"},
+ { "Sequential-Access", "Tape", "tape"},
+ { "Printer", "Printer", "lpr"},
+ { "WORM", "CD-ROM", "cdrom"},
+ { "CD-ROM", "CD-ROM", "cdrom"},
+ { "Scanner", "Scanner", "scanner"},
+ { "Flash Disk", "USB Flash Disk", "usbfldisk" },
+ { NULL, "Generic", "scsi"}
+ };
+ int i;
+
+ if (strstr(model, "Flash Disk")) {
+ type = "Flash Disk";
+ icon = "usbfldisk";
+ } else {
+ for (i = 0; type2icon[i].type != NULL; i++)
+ if (g_str_equal(buf + 8, type2icon[i].type))
+ break;
+
+ type = type2icon[i].label;
+ icon = type2icon[i].icon;
+ }
+ }
+
+ gchar *devid = g_strdup_printf("SCSI%d", n);
+ scsi_storage_list = h_strdup_cprintf("$%s$%s=\n", scsi_storage_list, devid, model);
+ storage_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n", storage_icons, devid, model, icon);
+
+ gchar *strhash = g_strdup_printf("[Device Information]\n"
+ "Model=%s\n", model);
+
+ const gchar *url = vendor_get_url(model);
+ if (url) {
+ strhash = h_strdup_cprintf("Vendor=%s (%s)\n",
+ strhash,
+ vendor_get_name(model),
+ url);
+ } else {
+ strhash = h_strdup_cprintf("Vendor=%s\n",
+ strhash,
+ vendor_get_name(model));
+ }
+
+ strhash = h_strdup_cprintf("Type=%s\n"
+ "Revision=%s\n"
+ "[SCSI Controller]\n"
+ "Controller=scsi%d\n"
+ "Channel=%d\n"
+ "ID=%d\n" "LUN=%d\n",
+ strhash,
+ type,
+ revision,
+ scsi_controller,
+ scsi_channel,
+ scsi_id,
+ scsi_lun);
+ g_hash_table_insert(moreinfo, devid, strhash);
+
+ g_free(model);
+ g_free(revision);
+ g_free(vendor);
+ }
+ }
+ fclose(proc_scsi);
+ }
+
+ if (n) {
+ storage_list = h_strconcat(storage_list, scsi_storage_list, NULL);
+ g_free(scsi_storage_list);
+ }
+}
+
+static gboolean
+remove_ide_devices(gpointer key, gpointer value, gpointer data)
+{
+ return g_str_has_prefix(key, "IDE");
+}
+
+void
+__scan_ide_devices(void)
+{
+ FILE *proc_ide;
+ gchar *device, iface, *model, *media, *pgeometry = NULL, *lgeometry =
+ NULL;
+ gint n = 0, i = 0, cache, nn = 0;
+ gchar *capab = NULL, *speed = NULL, *driver = NULL, *ide_storage_list;
+
+ /* remove old devices from global device table */
+ g_hash_table_foreach_remove(moreinfo, remove_ide_devices, NULL);
+
+ ide_storage_list = g_strdup("\n[IDE Disks]\n");
+
+ iface = 'a';
+ for (i = 0; i <= 16; i++) {
+ device = g_strdup_printf("/proc/ide/hd%c/model", iface);
+ if (g_file_test(device, G_FILE_TEST_EXISTS)) {
+ gchar buf[128];
+
+ cache = 0;
+
+ proc_ide = fopen(device, "r");
+ (void)fgets(buf, 128, proc_ide);
+ fclose(proc_ide);
+
+ buf[strlen(buf) - 1] = 0;
+
+ model = g_strdup(buf);
+
+ g_free(device);
+
+ device = g_strdup_printf("/proc/ide/hd%c/media", iface);
+ proc_ide = fopen(device, "r");
+ (void)fgets(buf, 128, proc_ide);
+ fclose(proc_ide);
+ buf[strlen(buf) - 1] = 0;
+
+ media = g_strdup(buf);
+ if (g_str_equal(media, "cdrom")) {
+ /* obtain cd-rom drive information from cdrecord */
+ GTimer *timer;
+ gchar *tmp = g_strdup_printf("cdrecord dev=/dev/hd%c -prcap 2>/dev/stdout", iface);
+ FILE *prcap;
+
+ if ((prcap = popen(tmp, "r"))) {
+ /* we need a timeout so cdrecord does not try to get information on cd drives
+ with inserted media, which is not possible currently. half second should be
+ enough. */
+ timer = g_timer_new();
+ g_timer_start(timer);
+
+ while (fgets(buf, 128, prcap) && g_timer_elapsed(timer, NULL) < 0.5) {
+ if (g_str_has_prefix(buf, " Does")) {
+ if (g_str_has_suffix(buf, "media\n") && !strstr(buf, "speed")) {
+ gchar *media_type = g_strstrip(strstr(buf, "Does "));
+ gchar **ttmp = g_strsplit(media_type, " ", 0);
+
+ capab = h_strdup_cprintf("\nCan %s#%d=%s\n",
+ capab,
+ ttmp[1], ++nn, ttmp[2]);
+
+ g_strfreev(ttmp);
+ } else if (strstr(buf, "Buffer-Underrun-Free")) {
+ capab = h_strdup_cprintf("\nSupports BurnProof=%s\n",
+ capab,
+ strstr(buf, "Does not") ? "No" : "Yes");
+ } else if (strstr(buf, "multi-session")) {
+ capab = h_strdup_cprintf("\nCan read multi-session CDs=%s\n",
+ capab,
+ strstr(buf, "Does not") ? "No" : "Yes");
+ } else if (strstr(buf, "audio CDs")) {
+ capab = h_strdup_cprintf("\nCan play audio CDs=%s\n",
+ capab,
+ strstr(buf, "Does not") ? "No" : "Yes");
+ } else if (strstr(buf, "PREVENT/ALLOW")) {
+ capab = h_strdup_cprintf("\nCan lock media=%s\n",
+ capab,
+ strstr(buf, "Does not") ? "No" : "Yes");
+ }
+ } else if ((strstr(buf, "read") || strstr(buf, "write")) && strstr(buf, "kB/s")) {
+ speed = g_strconcat(speed ? speed : "",
+ strreplacechr(g_strstrip(buf), ":", '='),
+ "\n", NULL);
+ } else if (strstr(buf, "Device seems to be")) {
+ driver = g_strdup_printf("Driver=%s\n", strchr(buf, ':') + 1);
+ }
+ }
+
+ pclose(prcap);
+ g_timer_destroy(timer);
+ }
+
+ g_free(tmp);
+ }
+ g_free(device);
+
+ device = g_strdup_printf("/proc/ide/hd%c/cache", iface);
+ if (g_file_test(device, G_FILE_TEST_EXISTS)) {
+ proc_ide = fopen(device, "r");
+ (void)fscanf(proc_ide, "%d", &cache);
+ fclose(proc_ide);
+ }
+ g_free(device);
+
+ device = g_strdup_printf("/proc/ide/hd%c/geometry", iface);
+ if (g_file_test(device, G_FILE_TEST_EXISTS)) {
+ gchar *tmp;
+
+ proc_ide = fopen(device, "r");
+
+ (void)fgets(buf, 64, proc_ide);
+ for (tmp = buf; *tmp; tmp++) {
+ if (*tmp >= '0' && *tmp <= '9')
+ break;
+ }
+
+ pgeometry = g_strdup(g_strstrip(tmp));
+
+ (void)fgets(buf, 64, proc_ide);
+ for (tmp = buf; *tmp; tmp++) {
+ if (*tmp >= '0' && *tmp <= '9')
+ break;
+ }
+ lgeometry = g_strdup(g_strstrip(tmp));
+
+ fclose(proc_ide);
+ }
+ g_free(device);
+
+ n++;
+
+ gchar *devid = g_strdup_printf("IDE%d", n);
+
+ ide_storage_list = h_strdup_cprintf("$%s$%s=\n", ide_storage_list,
+ devid, model);
+ storage_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n", storage_icons, devid,
+ model, g_str_equal(media, "cdrom") ? \
+ "cdrom" : "hdd");
+
+ gchar *strhash = g_strdup_printf("[Device Information]\n"
+ "Model=%s\n",
+ model);
+
+ const gchar *url = vendor_get_url(model);
+
+ if (url) {
+ strhash = h_strdup_cprintf("Vendor=%s (%s)\n",
+ strhash,
+ vendor_get_name(model),
+ url);
+ } else {
+ strhash = h_strdup_cprintf("Vendor=%s\n",
+ strhash,
+ vendor_get_name(model));
+ }
+
+ strhash = h_strdup_cprintf("Device Name=hd%c\n"
+ "Media=%s\n"
+ "Cache=%dkb\n",
+ strhash,
+ iface,
+ media,
+ cache);
+ if (driver) {
+ strhash = h_strdup_cprintf("%s\n", strhash, driver);
+
+ g_free(driver);
+ driver = NULL;
+ }
+
+ if (pgeometry && lgeometry) {
+ strhash = h_strdup_cprintf("[Geometry]\n"
+ "Physical=%s\n"
+ "Logical=%s\n",
+ strhash, pgeometry, lgeometry);
+
+ g_free(pgeometry);
+ pgeometry = NULL;
+ g_free(lgeometry);
+ lgeometry = NULL;
+ }
+
+ if (capab) {
+ strhash = h_strdup_cprintf("[Capabilities]\n%s", strhash, capab);
+
+ g_free(capab);
+ capab = NULL;
+ }
+
+ if (speed) {
+ strhash = h_strdup_cprintf("[Speeds]\n%s", strhash, speed);
+
+ g_free(speed);
+ speed = NULL;
+ }
+
+ g_hash_table_insert(moreinfo, devid, strhash);
+
+ g_free(model);
+ model = g_strdup("");
+ } else
+ g_free(device);
+
+ iface++;
+ }
+
+ if (n) {
+ storage_list = h_strconcat(storage_list, ide_storage_list, NULL);
+ g_free(ide_storage_list);
+ }
+}
diff --git a/modules/devices/usb.c b/modules/devices/usb.c
new file mode 100644
index 00000000..39914dd0
--- /dev/null
+++ b/modules/devices/usb.c
@@ -0,0 +1,349 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2008 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+/*
+ * FIXME:
+ * - listing with sysfs does not generate device hierarchy
+ */
+
+#include <string.h>
+
+#include "hardinfo.h"
+#include "devices.h"
+
+gchar *usb_list = NULL;
+
+static gboolean
+remove_usb_devices(gpointer key, gpointer value, gpointer data)
+{
+ return g_str_has_prefix(key, "USB");
+}
+
+void __scan_usb_sysfs_add_device(gchar * endpoint, int n)
+{
+ gchar *manufacturer, *product, *mxpwr, *tmp, *strhash;
+ gint bus, classid, vendor, prodid;
+ gfloat version, speed;
+
+ classid = h_sysfs_read_int(endpoint, "bDeviceClass");
+ vendor = h_sysfs_read_int(endpoint, "idVendor");
+ prodid = h_sysfs_read_int(endpoint, "idProduct");
+ bus = h_sysfs_read_int(endpoint, "busnum");
+ speed = h_sysfs_read_float(endpoint, "speed");
+ version = h_sysfs_read_float(endpoint, "version");
+
+ if (!(mxpwr = h_sysfs_read_string(endpoint, "bMaxPower"))) {
+ mxpwr = g_strdup("0 mA");
+ }
+
+ if (!(manufacturer = h_sysfs_read_string(endpoint, "manufacturer"))) {
+ manufacturer = g_strdup("Unknown");
+ }
+
+ if (!(product = h_sysfs_read_string(endpoint, "product"))) {
+ if (classid == 9) {
+ product = g_strdup_printf("USB %.2f Hub", version);
+ } else {
+ product = g_strdup_printf("Unknown USB %.2f Device (class %d)", version, classid);
+ }
+ }
+
+ const gchar *url = vendor_get_url(manufacturer);
+ if (url) {
+ tmp = g_strdup_printf("%s (%s)", vendor_get_name(manufacturer), url);
+
+ g_free(manufacturer);
+ manufacturer = tmp;
+ }
+
+ tmp = g_strdup_printf("USB%d", n);
+ usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, product);
+
+ strhash = g_strdup_printf("[Device Information]\n"
+ "Product=%s\n"
+ "Manufacturer=%s\n"
+ "Speed=%.2fMbit/s\n"
+ "Max Current=%s\n"
+ "[Misc]\n"
+ "USB Version=%.2f\n"
+ "Class=0x%x\n"
+ "Vendor=0x%x\n"
+ "Product ID=0x%x\n"
+ "Bus=%d\n",
+ product,
+ manufacturer,
+ speed,
+ mxpwr,
+ version, classid, vendor, prodid, bus);
+
+ g_hash_table_insert(moreinfo, tmp, strhash);
+
+ g_free(manufacturer);
+ g_free(product);
+ g_free(mxpwr);
+}
+
+gboolean __scan_usb_sysfs(void)
+{
+ GDir *sysfs;
+ gchar *filename;
+ const gchar *sysfs_path = "/sys/class/usb_endpoint";
+ gint usb_device_number = 0;
+
+ if (!(sysfs = g_dir_open(sysfs_path, 0, NULL))) {
+ return FALSE;
+ }
+
+ if (usb_list) {
+ g_hash_table_foreach_remove(moreinfo, remove_usb_devices, NULL);
+ g_free(usb_list);
+ }
+ usb_list = g_strdup("[USB Devices]\n");
+
+ while ((filename = (gchar *) g_dir_read_name(sysfs))) {
+ gchar *endpoint =
+ g_build_filename(sysfs_path, filename, "device", NULL);
+ gchar *temp;
+
+ temp = g_build_filename(endpoint, "idVendor", NULL);
+ if (g_file_test(temp, G_FILE_TEST_EXISTS)) {
+ __scan_usb_sysfs_add_device(endpoint, ++usb_device_number);
+ }
+
+ g_free(temp);
+ g_free(endpoint);
+ }
+
+ g_dir_close(sysfs);
+
+ return usb_device_number > 0;
+}
+
+gboolean __scan_usb_procfs(void)
+{
+ FILE *dev;
+ gchar buffer[128];
+ gchar *tmp, *manuf = NULL, *product = NULL, *mxpwr;
+ gint bus, level, port, classid, trash;
+ gint vendor, prodid;
+ gfloat ver, rev, speed;
+ int n = 0;
+
+ dev = fopen("/proc/bus/usb/devices", "r");
+ if (!dev)
+ return 0;
+
+ if (usb_list) {
+ g_hash_table_foreach_remove(moreinfo, remove_usb_devices, NULL);
+ g_free(usb_list);
+ }
+ usb_list = g_strdup("[USB Devices]\n");
+
+ while (fgets(buffer, 128, dev)) {
+ tmp = buffer;
+
+ switch (*tmp) {
+ case 'T':
+ sscanf(tmp,
+ "T: Bus=%d Lev=%d Prnt=%d Port=%d Cnt=%d Dev#=%d Spd=%f",
+ &bus, &level, &trash, &port, &trash, &trash, &speed);
+ break;
+ case 'D':
+ sscanf(tmp, "D: Ver=%f Cls=%x", &ver, &classid);
+ break;
+ case 'P':
+ sscanf(tmp, "P: Vendor=%x ProdID=%x Rev=%f",
+ &vendor, &prodid, &rev);
+ break;
+ case 'S':
+ if (strstr(tmp, "Manufacturer=")) {
+ manuf = g_strdup(strchr(tmp, '=') + 1);
+ remove_linefeed(manuf);
+ } else if (strstr(tmp, "Product=")) {
+ product = g_strdup(strchr(tmp, '=') + 1);
+ remove_linefeed(product);
+ }
+ break;
+ case 'C':
+ mxpwr = strstr(buffer, "MxPwr=") + 6;
+
+ tmp = g_strdup_printf("USB%d", ++n);
+
+ if (*product == '\0') {
+ g_free(product);
+ if (classid == 9) {
+ product = g_strdup_printf("USB %.2f Hub", ver);
+ } else {
+ product =
+ g_strdup_printf
+ ("Unknown USB %.2f Device (class %d)", ver,
+ classid);
+ }
+ }
+
+
+ if (classid == 9) { /* hub */
+ usb_list = h_strdup_cprintf("[%s#%d]\n",
+ usb_list, product, n);
+ } else { /* everything else */
+ usb_list = h_strdup_cprintf("$%s$%s=\n",
+ usb_list, tmp, product);
+
+ const gchar *url = vendor_get_url(manuf);
+ if (url) {
+ gchar *tmp =
+ g_strdup_printf("%s (%s)", vendor_get_name(manuf),
+ url);
+ g_free(manuf);
+ manuf = tmp;
+ }
+
+ gchar *strhash = g_strdup_printf("[Device Information]\n"
+ "Product=%s\n",
+ product);
+ if (manuf && strlen(manuf))
+ strhash = h_strdup_cprintf("Manufacturer=%s\n",
+ strhash, manuf);
+
+ strhash = h_strdup_cprintf("[Port #%d]\n"
+ "Speed=%.2fMbit/s\n"
+ "Max Current=%s\n"
+ "[Misc]\n"
+ "USB Version=%.2f\n"
+ "Revision=%.2f\n"
+ "Class=0x%x\n"
+ "Vendor=0x%x\n"
+ "Product ID=0x%x\n"
+ "Bus=%d\n" "Level=%d\n",
+ strhash,
+ port, speed, mxpwr,
+ ver, rev, classid,
+ vendor, prodid, bus, level);
+
+ g_hash_table_insert(moreinfo, tmp, strhash);
+ }
+
+ g_free(manuf);
+ g_free(product);
+ manuf = g_strdup("");
+ product = g_strdup("");
+ }
+ }
+
+ fclose(dev);
+
+ return n > 0;
+}
+
+void __scan_usb_lsusb_add_device(char *buffer, FILE *lsusb, int usb_device_number)
+{
+ gint bus, device, vendor_id, product_id;
+ gchar *product, *vendor, *max_power, *tmp, *strhash;
+
+ sscanf(buffer, "Bus %d Device %d: ID %x:%x",
+ &bus, &device, &vendor_id, &product_id);
+
+ while (fgets(buffer, 512, lsusb)) {
+ if (g_str_has_prefix(buffer, " idVendor")) {
+ vendor = g_strstrip(g_strdup(buffer + 28));
+ } else if (g_str_has_prefix(buffer, " idProduct")) {
+ product = g_strstrip(g_strdup(buffer + 28));
+ } else if (g_str_has_prefix(buffer, " MaxPower")) {
+ max_power = g_strstrip(g_strdup(buffer + 26));
+ } else if (g_str_has_prefix(buffer, "\n")) {
+ /* device separator */
+ break;
+ }
+ }
+
+ tmp = g_strdup_printf("USB%d", usb_device_number);
+ usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, product);
+
+ strhash = g_strdup_printf("[Device Information]\n"
+ "Product=%s\n"
+ "Manufacturer=%s\n"
+ "Max Current=%s\n"
+ "[Misc]\n"
+ "USB Version=%.2f\n"
+ "Class=0x%x\n"
+ "Vendor=0x%x\n"
+ "Product ID=0x%x\n"
+ "Bus=%d\n",
+ product,
+ vendor,
+ max_power,
+ 0.0f /* FIXME */,
+ 0 /* FIXME */,
+ vendor_id, product_id, bus);
+
+ g_hash_table_insert(moreinfo, tmp, strhash);
+
+ g_free(vendor);
+ g_free(product);
+ g_free(max_power);
+}
+
+gboolean __scan_usb_lsusb(void)
+{
+ static gchar *lsusb_path = NULL;
+ int usb_device_number = 0;
+ FILE *lsusb;
+ char buffer[512], *temp;
+
+ if (!lsusb_path) {
+ if (!(lsusb_path = find_program("lsusb"))) {
+ DEBUG("lsusb not found");
+
+ return FALSE;
+ }
+ }
+
+ temp = g_strdup_printf("%s -v", lsusb_path);
+ if (!(lsusb = popen(temp, "r"))) {
+ DEBUG("cannot run %s", lsusb_path);
+
+ g_free(temp);
+ return FALSE;
+ }
+
+ g_free(temp);
+
+ if (usb_list) {
+ g_hash_table_foreach_remove(moreinfo, remove_usb_devices, NULL);
+ g_free(usb_list);
+ }
+ usb_list = g_strdup("[USB Devices]\n");
+
+ while (fgets(buffer, sizeof(buffer), lsusb)) {
+ if (g_str_has_prefix(buffer, "Bus ")) {
+ __scan_usb_lsusb_add_device(buffer, lsusb, ++usb_device_number);
+ }
+ }
+
+ pclose(lsusb);
+
+ return usb_device_number > 0;
+}
+
+void __scan_usb(void)
+{
+ if (!__scan_usb_procfs()) {
+ if (!__scan_usb_sysfs()) {
+ __scan_usb_lsusb();
+ }
+ }
+}
diff --git a/modules/devices/x86/processor.c b/modules/devices/x86/processor.c
new file mode 100644
index 00000000..aee409f1
--- /dev/null
+++ b/modules/devices/x86/processor.c
@@ -0,0 +1,562 @@
+/*
+ * HardInfo - Displays System Information
+ * Copyright (C) 2003-2006 Leandro A. F. Pereira <leandro@hardinfo.org>
+ *
+ * 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, version 2.
+ *
+ * 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
+ */
+#include "hardinfo.h"
+#include "devices.h"
+
+/*
+ * This function is partly based on x86cpucaps
+ * by Osamu Kayasono <jacobi@jcom.home.ne.jp>
+ */
+void get_processor_strfamily(Processor * processor)
+{
+ gint family = processor->family;
+ gint model = processor->model;
+
+ if (g_str_equal(processor->vendor_id, "GenuineIntel")) {
+ if (family == 4) {
+ processor->strmodel = g_strdup("i486 series");
+ } else if (family == 5) {
+ if (model < 4) {
+ processor->strmodel = g_strdup("Pentium Classic");
+ } else {
+ processor->strmodel = g_strdup("Pentium MMX");
+ }
+ } else if (family == 6) {
+ if (model <= 1) {
+ processor->strmodel = g_strdup("Pentium Pro");
+ } else if (model < 7) {
+ processor->strmodel = g_strdup("Pentium II/Pentium II Xeon/Celeron");
+ } else if (model == 9) {
+ processor->strmodel = g_strdup("Pentium M");
+ } else {
+ processor->strmodel = g_strdup("Pentium III/Pentium III Xeon/Celeron/Core Duo/Core Duo 2");
+ }
+ } else if (family > 6) {
+ processor->strmodel = g_strdup("Pentium 4");
+ } else {
+ processor->strmodel = g_strdup("i386 class");
+ }
+ } else if (g_str_equal(processor->vendor_id, "AuthenticAMD")) {
+ if (family == 4) {
+ if (model <= 9) {
+ processor->strmodel = g_strdup("AMD i80486 series");
+ } else {
+ processor->strmodel = g_strdup("AMD 5x86");
+ }
+ } else if (family == 5) {
+ if (model <= 3) {
+ processor->strmodel = g_strdup("AMD K5");
+ } else if (model <= 7) {
+ processor->strmodel = g_strdup("AMD K6");
+ } else if (model == 8) {
+ processor->strmodel = g_strdup("AMD K6-2");
+ } else if (model == 9) {
+ processor->strmodel = g_strdup("AMD K6-III");
+ } else {
+ processor->strmodel = g_strdup("AMD K6-2+/III+");
+ }
+ } else if (family == 6) {
+ if (model == 1) {
+ processor->strmodel = g_strdup("AMD Athlon (K7)");
+ } else if (model == 2) {
+ processor->strmodel = g_strdup("AMD Athlon (K75)");
+ } else if (model == 3) {
+ processor->strmodel = g_strdup("AMD Duron (Spitfire)");
+ } else if (model == 4) {
+ processor->strmodel = g_strdup("AMD Athlon (Thunderbird)");
+ } else if (model == 6) {
+ processor->strmodel = g_strdup("AMD Athlon XP/MP/4 (Palomino)");
+ } else if (model == 7) {
+ processor->strmodel = g_strdup("AMD Duron (Morgan)");
+ } else if (model == 8) {
+ processor->strmodel = g_strdup("AMD Athlon XP/MP (Thoroughbred)");
+ } else if (model == 10) {
+ processor->strmodel = g_strdup("AMD Athlon XP/MP (Barton)");
+ } else {
+ processor->strmodel = g_strdup("AMD Athlon (unknown)");
+ }
+ } else if (family > 6) {
+ processor->strmodel = g_strdup("AMD Opteron/Athlon64/FX");
+ } else {
+ processor->strmodel = g_strdup("AMD i386 class");
+ }
+ } else if (g_str_equal(processor->vendor_id, "CyrixInstead")) {
+ if (family == 4) {
+ processor->strmodel = g_strdup("Cyrix 5x86");
+ } else if (family == 5) {
+ processor->strmodel = g_strdup("Cyrix M1 (6x86)");
+ } else if (family == 6) {
+ if (model == 0) {
+ processor->strmodel = g_strdup("Cyrix M2 (6x86MX)");
+ } else if (model <= 5) {
+ processor->strmodel = g_strdup("VIA Cyrix III (M2 core)");
+ } else if (model == 6) {
+ processor->strmodel = g_strdup("VIA Cyrix III (WinChip C5A)");
+ } else if (model == 7) {
+ processor->strmodel = g_strdup("VIA Cyrix III (WinChip C5B/C)");
+ } else {
+ processor->strmodel = g_strdup("VIA Cyrix III (WinChip C5C-T)");
+ }
+ } else {
+ processor->strmodel = g_strdup("Cyrix i386 class");
+ }
+ } else if (g_str_equal(processor->vendor_id, "CentaurHauls")) {
+ if (family == 5) {
+ if (model <= 4) {
+ processor->strmodel = g_strdup("Centaur WinChip C6");
+ } else if (model <= 8) {
+ processor->strmodel = g_strdup("Centaur WinChip 2");
+ } else {
+ processor->strmodel = g_strdup("Centaur WinChip 2A");
+ }
+ } else {
+ processor->strmodel = g_strdup("Centaur i386 class");
+ }
+ } else if (g_str_equal(processor->vendor_id, "GenuineTMx86")) {
+ processor->strmodel = g_strdup("Transmeta Crusoe TM3x00/5x00");
+ } else {
+ processor->strmodel = g_strdup("Unknown");
+ }
+}
+
+static gchar *__cache_get_info_as_string(Processor *processor)
+{
+ gchar *result = g_strdup("");
+ GSList *cache_list;
+ ProcessorCache *cache;
+
+ if (!processor->cache) {
+ return g_strdup("Cache information not available=\n");
+ }
+
+ for (cache_list = processor->cache; cache_list; cache_list = cache_list->next) {
+ cache = (ProcessorCache *)cache_list->data;
+
+ result = h_strdup_cprintf("Level %d (%s)=%d-way set-associative, %d sets, %dKB size\n",
+ result,
+ cache->level,
+ cache->type,
+ cache->ways_of_associativity,
+ cache->number_of_sets,
+ cache->size);
+ }
+
+ return result;
+}
+
+static void __cache_obtain_info(Processor *processor, gint processor_number)
+{
+ ProcessorCache *cache;
+ gchar *endpoint, *entry, *index;
+ gint i;
+
+ endpoint = g_strdup_printf("/sys/devices/system/cpu/cpu%d/cache", processor_number);
+
+ for (i = 0; ; i++) {
+ cache = g_new0(ProcessorCache, 1);
+
+ index = g_strdup_printf("index%d/", i);
+
+ entry = g_strconcat(index, "type", NULL);
+ cache->type = h_sysfs_read_string(endpoint, entry);
+ g_free(entry);
+
+ if (!cache->type) {
+ g_free(cache);
+ g_free(index);
+ goto fail;
+ }
+
+ entry = g_strconcat(index, "level", NULL);
+ cache->level = h_sysfs_read_int(endpoint, entry);
+ g_free(entry);
+
+ entry = g_strconcat(index, "number_of_sets", NULL);
+ cache->number_of_sets = h_sysfs_read_int(endpoint, entry);
+ g_free(entry);
+
+ entry = g_strconcat(index, "physical_line_partition", NULL);
+ cache->physical_line_partition = h_sysfs_read_int(endpoint, entry);
+ g_free(entry);
+
+ entry = g_strconcat(index, "size", NULL);
+ cache->size = h_sysfs_read_int(endpoint, entry);
+ g_free(entry);
+
+
+ entry = g_strconcat(index, "ways_of_associativity", NULL);
+ cache->ways_of_associativity = h_sysfs_read_int(endpoint, entry);
+ g_free(entry);
+
+ g_free(index);
+
+ processor->cache = g_slist_append(processor->cache, cache);
+ }
+
+fail:
+ g_free(endpoint);
+}
+
+GSList *processor_scan(void)
+{
+ GSList *procs = NULL;
+ Processor *processor = NULL;
+ FILE *cpuinfo;
+ gchar buffer[512];
+ gint processor_number = 0;
+
+ cpuinfo = fopen("/proc/cpuinfo", "r");
+ if (!cpuinfo)
+ return NULL;
+
+ while (fgets(buffer, 512, cpuinfo)) {
+ gchar **tmp = g_strsplit(buffer, ":", 2);
+
+ if (g_str_has_prefix(tmp[0], "processor")) {
+ if (processor) {
+ get_processor_strfamily(processor);
+ procs = g_slist_append(procs, processor);
+ }
+
+ processor = g_new0(Processor, 1);
+
+ __cache_obtain_info(processor, processor_number++);
+ }
+
+ if (tmp[0] && tmp[1]) {
+ tmp[0] = g_strstrip(tmp[0]);
+ tmp[1] = g_strstrip(tmp[1]);
+
+ get_str("model name", processor->model_name);
+ get_str("vendor_id", processor->vendor_id);
+ get_str("flags", processor->flags);
+ get_int("cache size", processor->cache_size);
+ get_float("cpu MHz", processor->cpu_mhz);
+ get_float("bogomips", processor->bogomips);
+
+ get_str("fpu", processor->has_fpu);
+
+ get_str("fdiv_bug", processor->bug_fdiv);
+ get_str("hlt_bug", processor->bug_hlt);
+ get_str("f00f_bug", processor->bug_f00f);
+ get_str("coma_bug", processor->bug_coma);
+
+ get_int("model", processor->model);
+ get_int("cpu family", processor->family);
+ get_int("stepping", processor->stepping);
+
+ get_int("processor", processor->id);
+ }
+ g_strfreev(tmp);
+ }
+
+ if (processor) {
+ get_processor_strfamily(processor);
+ procs = g_slist_append(procs, processor);
+ }
+
+ fclose(cpuinfo);
+
+ return procs;
+}
+
+/*
+ * Sources:
+ * - Linux' cpufeature.h
+ * - http://gentoo-wiki.com/Cpuinfo
+ * - Intel IA-32 Architecture Software Development Manual
+ */
+static struct {
+ char *name, *meaning;
+} flag_meaning[] = {
+ { "3dnow", "3DNow! Technology" },
+ { "3dnowext", "Extended 3DNow! Technology" },
+ { "fpu", "Floating Point Unit" },
+ { "vme", "Virtual 86 Mode Extension" },
+ { "de", "Debug Extensions - I/O breakpoints" },
+ { "pse", "Page Size Extensions (4MB pages)" },
+ { "tsc", "Time Stamp Counter and RDTSC instruction" },
+ { "msr", "Model Specific Registers" },
+ { "pae", "Physical Address Extensions" },
+ { "mce", "Machine Check Architeture" },
+ { "cx8", "CMPXCHG8 instruction" },
+ { "apic", "Advanced Programmable Interrupt Controller" },
+ { "sep", "Fast System Call (SYSENTER/SYSEXIT)" },
+ { "mtrr", "Memory Type Range Registers" },
+ { "pge", "Page Global Enable" },
+ { "mca", "Machine Check Architecture" },
+ { "cmov", "Conditional Move instruction" },
+ { "pat", "Page Attribute Table" },
+ { "pse36", "36bit Page Size Extensions" },
+ { "psn", "96 bit Processor Serial Number" },
+ { "mmx", "MMX technology" },
+ { "mmxext", "Extended MMX Technology" },
+ { "cflush", "Cache Flush" },
+ { "dtes", "Debug Trace Store" },
+ { "fxsr", "FXSAVE and FXRSTOR instructions" },
+ { "kni", "Streaming SIMD instructions" },
+ { "xmm", "Streaming SIMD instructions" },
+ { "ht", "HyperThreading" },
+ { "mp", "Multiprocessing Capable" },
+ { "sse", "SSE instructions" },
+ { "sse2", "SSE2 (WNI) instructions" },
+ { "acc", "Automatic Clock Control" },
+ { "ia64", "IA64 Instructions" },
+ { "syscall", "SYSCALL and SYSEXIT instructions" },
+ { "nx", "No-execute Page Protection" },
+ { "xd", "Execute Disable" },
+ { "clflush", "Cache Line Flush instruction" },
+ { "acpi", "Thermal Monitor and Software Controlled Clock" },
+ { "dts", "Debug Store" },
+ { "ss", "Self Snoop" },
+ { "tm", "Thermal Monitor" },
+ { "pbe", "Pending Break Enable" },
+ { "pb", "Pending Break Enable" },
+ { "pn", "Processor serial number" },
+ { "ds", "Debug Store" },
+ { "xmm2", "Streaming SIMD Extensions-2" },
+ { "xmm3", "Streaming SIMD Extensions-3" },
+ { "selfsnoop", "CPU self snoop" },
+ { "rdtscp", "RDTSCP" },
+ { "recovery", "CPU in recovery mode" },
+ { "longrun", "Longrun power control" },
+ { "lrti", "LongRun table interface" },
+ { "cxmmx", "Cyrix MMX extensions" },
+ { "k6_mtrr", "AMD K6 nonstandard MTRRs" },
+ { "cyrix_arr", "Cyrix ARRs (= MTRRs)" },
+ { "centaur_mcr","Centaur MCRs (= MTRRs)" },
+ { "constant_tsc","TSC ticks at a constant rate" },
+ { "up", "smp kernel running on up" },
+ { "fxsave_leak","FXSAVE leaks FOP/FIP/FOP" },
+ { "arch_perfmon","Intel Architectural PerfMon" },
+ { "pebs", "Precise-Event Based Sampling" },
+ { "bts", "Branch Trace Store" },
+ { "sync_rdtsc", "RDTSC synchronizes the CPU" },
+ { "rep_good", "rep microcode works well on this CPU" },
+ { "mwait", "Monitor/Mwait support" },
+ { "ds_cpl", "CPL Qualified Debug Store" },
+ { "est", "Enhanced SpeedStep" },
+ { "tm2", "Thermal Monitor 2" },
+ { "cid", "Context ID" },
+ { "xtpr", "Send Task Priority Messages" },
+ { "xstore", "on-CPU RNG present (xstore insn)" },
+ { "xstore_en", "on-CPU RNG enabled" },
+ { "xcrypt", "on-CPU crypto (xcrypt insn)" },
+ { "xcrypt_en", "on-CPU crypto enabled" },
+ { "ace2", "Advanced Cryptography Engine v2" },
+ { "ace2_en", "ACE v2 enabled" },
+ { "phe", "PadLock Hash Engine" },
+ { "phe_en", "PHE enabled" },
+ { "pmm", "PadLock Montgomery Multiplier" },
+ { "pmm_en", "PMM enabled" },
+ { "lahf_lm", "LAHF/SAHF in long mode" },
+ { "cmp_legacy", "HyperThreading not valid" },
+ { "lm", "LAHF/SAHF in long mode" },
+ { "ds_cpl", "CPL Qualified Debug Store" },
+ { "vmx", "Virtualization support (Intel)" },
+ { "svm", "Virtualization support (AMD)" },
+ { "est", "Enhanced SpeedStep" },
+ { "tm2", "Thermal Monitor 2" },
+ { "ssse3", "Supplemental Streaming SIMD Extension 3" },
+ { "cx16", "CMPXCHG16B instruction" },
+ { "xptr", "Send Task Priority Messages" },
+ { "pebs", "Precise Event Based Sampling" },
+ { "bts", "Branch Trace Store" },
+ { "ida", "Intel Dynamic Acceleration" },
+ { "arch_perfmon","Intel Architectural PerfMon" },
+ { "pni", "Streaming SIMD Extension 3 (Prescott New Instruction)" },
+ { "rep_good", "rep microcode works well on this CPU" },
+ { "ts", "Thermal Sensor" },
+ { "sse3", "Streaming SIMD Extension 3" },
+ { "sse4", "Streaming SIMD Extension 4" },
+ { "tni", "Tejas New Instruction" },
+ { "nni", "Nehalem New Instruction" },
+ { "tpr", "Task Priority Register" },
+ { "vid", "Voltage Identifier" },
+ { "fid", "Frequency Identifier" },
+ { "dtes64", "64-bit Debug Store" },
+ { "monitor", "Monitor/Mwait support" },
+ { NULL, NULL },
+};
+
+GHashTable *cpu_flags = NULL;
+
+void cpu_flags_init(void)
+{
+ gint i;
+ gchar *path;
+
+ cpu_flags = g_hash_table_new(g_str_hash, g_str_equal);
+
+ path = g_build_filename(g_get_home_dir(), ".hardinfo", "cpuflags.conf", NULL);
+ if (!g_file_test(path, G_FILE_TEST_EXISTS)) {
+ DEBUG("using internal CPU flags database");
+
+ for (i = 0; flag_meaning[i].name != NULL; i++) {
+ g_hash_table_insert(cpu_flags, flag_meaning[i].name,
+ flag_meaning[i].meaning);
+ }
+ } else {
+ GKeyFile *flags_file;
+
+ DEBUG("using %s as CPU flags database", path);
+
+ flags_file = g_key_file_new();
+ if (g_key_file_load_from_file(flags_file, path, 0, NULL)) {
+ gchar **flag_keys;
+
+ flag_keys = g_key_file_get_keys(flags_file, "flags",
+ NULL, NULL);
+ for (i = 0; flag_keys[i]; i++) {
+ gchar *meaning;
+
+ meaning = g_key_file_get_string(flags_file, "flags",
+ flag_keys[i], NULL);
+
+ g_hash_table_insert(cpu_flags, g_strdup(flag_keys[i]), meaning);
+
+ /* can't free meaning */
+ }
+
+ g_strfreev(flag_keys);
+ }
+
+ g_key_file_free(flags_file);
+ }
+
+ g_free(path);
+}
+
+gchar *processor_get_capabilities_from_flags(gchar * strflags)
+{
+ /* FIXME:
+ * - Separate between processor capabilities, additional instructions and whatnot.
+ */
+ gchar **flags, **old;
+ gchar *tmp = NULL;
+ gint j = 0;
+
+ if (!cpu_flags) {
+ cpu_flags_init();
+ }
+
+ flags = g_strsplit(strflags, " ", 0);
+ old = flags;
+
+ while (flags[j]) {
+ gchar *meaning = g_hash_table_lookup(cpu_flags, flags[j]);
+
+ if (meaning) {
+ tmp = h_strdup_cprintf("%s=%s\n", tmp, flags[j], meaning);
+ } else {
+ tmp = h_strdup_cprintf("%s=\n", tmp, flags[j]);
+ }
+ j++;
+ }
+
+ g_strfreev(old);
+ return tmp;
+}
+
+gchar *processor_get_detailed_info(Processor * processor)
+{
+ gchar *tmp, *ret, *cache_info;
+
+ tmp = processor_get_capabilities_from_flags(processor->flags);
+ cache_info = __cache_get_info_as_string(processor);
+
+ ret = g_strdup_printf("[Processor]\n"
+ "Name=%s\n"
+ "Family, model, stepping=%d, %d, %d (%s)\n"
+ "Vendor=%s\n"
+ "[Configuration]\n"
+ "Cache Size=%dkb\n"
+ "Frequency=%.2fMHz\n"
+ "BogoMIPS=%.2f\n"
+ "Byte Order=%s\n"
+ "[Features]\n"
+ "FDIV Bug=%s\n"
+ "HLT Bug=%s\n"
+ "F00F Bug=%s\n"
+ "Coma Bug=%s\n"
+ "Has FPU=%s\n"
+ "[Cache]\n"
+ "%s\n"
+ "[Capabilities]\n"
+ "%s",
+ processor->model_name,
+ processor->family,
+ processor->model,
+ processor->stepping,
+ processor->strmodel,
+ vendor_get_name(processor->vendor_id),
+ processor->cache_size,
+ processor->cpu_mhz, processor->bogomips,
+#if G_BYTE_ORDER == G_LITTLE_ENDIAN
+ "Little Endian",
+#else
+ "Big Endian",
+#endif
+ processor->bug_fdiv ? processor->bug_fdiv : "no",
+ processor->bug_hlt ? processor->bug_hlt : "no",
+ processor->bug_f00f ? processor->bug_f00f : "no",
+ processor->bug_coma ? processor->bug_coma : "no",
+ processor->has_fpu ? processor->has_fpu : "no",
+ cache_info,
+ tmp);
+ g_free(tmp);
+ g_free(cache_info);
+
+ return ret;
+}
+
+gchar *processor_get_info(GSList * processors)
+{
+ Processor *processor;
+
+ if (g_slist_length(processors) > 1) {
+ gchar *ret, *tmp, *hashkey;
+ GSList *l;
+
+ tmp = g_strdup("");
+
+ for (l = processors; l; l = l->next) {
+ processor = (Processor *) l->data;
+
+ tmp = g_strdup_printf("%s$CPU%d$%s=%.2fMHz\n",
+ tmp, processor->id,
+ processor->model_name,
+ processor->cpu_mhz);
+
+ hashkey = g_strdup_printf("CPU%d", processor->id);
+ g_hash_table_insert(moreinfo, hashkey,
+ processor_get_detailed_info(processor));
+ }
+
+ ret = g_strdup_printf("[$ShellParam$]\n"
+ "ViewType=1\n"
+ "[Processors]\n"
+ "%s", tmp);
+ g_free(tmp);
+
+ return ret;
+ }
+
+ processor = (Processor *) processors->data;
+ return processor_get_detailed_info(processor);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-10-31 19:22:47 +0000