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;
}
static void
report_text_key_value(ReportContext * ctx, gchar * key, gchar * value)
{
if (strlen(value))
ctx->output =
h_strdup_cprintf("%s\t\t: %s\n", ctx->output, key, value);
else
ctx->output = h_strdup_cprintf("%s\n", ctx->output, key);
}
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"));
}
}
static void report_html_subsubtitle(ReportContext * ctx, gchar * text)
{
ctx->output = h_strdup_cprintf("<tr><td colspan=\"2\" class=\"ssti"
"tle\">%s</td></tr>\n",
ctx->output,
text);
}
void
scan_nfs_shared_directories(void)
{
FILE *exports;
gint count = 0;
gchar buf[512];
if (nfs_shares_list) {
g_free(nfs_shares_list);
}
nfs_shares_list = g_strdup("");
if ((exports = fopen("/etc/exports", "r"))) {
while (fgets(buf, 512, exports)) {
if (buf[0] != '/')
continue;
strend(buf, ' ');
strend(buf, '\t');
nfs_shares_list = h_strdup_cprintf("%s=\n",
buf, nfs_shares_list);
count++;
}
fclose(exports);
}
if (!count) {
g_free(nfs_shares_list);
nfs_shares_list = g_strdup("No NFS exports=\n");
}
}
static void
report_html_key_value(ReportContext * ctx, gchar * key, gchar * value)
{
ctx->output = h_strdup_cprintf("<tr><td class=\"field\">%s</td>"
"<td class=\"value\">%s</td></tr>\n",
ctx->output,
key, value);
}
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_path && (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 report_text_subtitle(ReportContext * ctx, gchar * text)
{
gchar *str = ctx->output;
int i = strlen(text);
str = h_strdup_cprintf("\n%s\n", str, text);
for (; i; i--)
str = h_strconcat(str, "-", NULL);
str = h_strconcat(str, "\n\n", NULL);
ctx->output = str;
}
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_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);
}
}
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);
}
}
gchar *
computer_get_alsacards(Computer * computer)
{
GSList *p;
gchar *tmp = g_strdup(_("[Audio Devices]\n"));
gint n = 0;
if (computer->alsa) {
for (p = computer->alsa->cards; p; p = p->next) {
AlsaCard *ac = (AlsaCard *) p->data;
tmp = h_strdup_cprintf(_("Audio Adapter#%d=%s\n"),
tmp, ++n, ac->friendly_name);
}
}
return tmp;
}
void
scan_groups_do(void)
{
struct group *group_;
setgrent();
group_ = getgrent();
if (!group_)
return;
g_free(groups);
groups = g_strdup("");
while (group_) {
groups = h_strdup_cprintf("%s=%d\n", groups, group_->gr_name, group_->gr_gid);
group_ = getgrent();
}
endgrent();
}
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;
}
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 */
moreinfo_del_with_prefix("DEV:PRN");
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);
}
}
moreinfo_add_with_prefix("DEV", prn_id, prn_moreinfo);
g_free(prn_id);
g_hash_table_destroy(options);
}
cups_dests_free(num_dests, dests);
} else {
printer_list = g_strdup(_("[Printers]\n"
"No printers found=\n"));
}
}
static void scan_net_interfaces_24(void)
{
FILE *proc_net;
NetInfo ni;
gchar buffer[256];
gchar *devid, *detailed;
gdouble recv_bytes;
gdouble recv_errors;
gdouble recv_packets;
gdouble trans_bytes;
gdouble trans_errors;
gdouble trans_packets;
if (!g_file_test("/proc/net/dev", G_FILE_TEST_EXISTS)) {
if (network_interfaces) {
g_free(network_interfaces);
network_interfaces = g_strdup("[Network Interfaces]\n"
"None found=\n");
}
return;
}
if (network_interfaces) {
g_free(network_interfaces);
}
if (network_icons) {
g_free(network_icons);
}
network_interfaces = g_strdup("[Network Interfaces]\n");
network_icons = g_strdup("");
proc_net = fopen("/proc/net/dev", "r");
if (!proc_net)
return;
while (fgets(buffer, 256, proc_net)) {
if (strchr(buffer, ':')) {
gint trash;
gchar ifacename[16];
gchar *buf = buffer;
gchar *iface_type, *iface_icon;
gint i;
buf = g_strstrip(buf);
memset(ifacename, 0, 16);
for (i = 0; buffer[i] != ':' && i < 16; i++) {
ifacename[i] = buffer[i];
}
buf = strchr(buf, ':') + 1;
/* iface: bytes packets errs drop fifo frame compressed multicast */
sscanf(buf, "%lf %lf %lf %d %d %d %d %d %lf %lf %lf",
&recv_bytes, &recv_packets,
&recv_errors, &trash, &trash, &trash, &trash,
&trash, &trans_bytes, &trans_packets, &trans_errors);
gdouble recv_mb = recv_bytes / 1048576.0;
gdouble trans_mb = trans_bytes / 1048576.0;
get_net_info(ifacename, &ni);
devid = g_strdup_printf("NET%s", ifacename);
network_interfaces =
h_strdup_cprintf
("$%s$%s=%s|%.2lfMiB|%.2lfMiB\n",
network_interfaces, devid, ifacename, ni.ip[0] ? ni.ip : "",
trans_mb, recv_mb);
net_get_iface_type(ifacename, &iface_type, &iface_icon, &ni);
network_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n",
network_icons, devid,
ifacename, iface_icon);
detailed = g_strdup_printf("[Network Adapter Properties]\n"
"Interface Type=%s\n"
"Hardware Address (MAC)=%02x:%02x:%02x:%02x:%02x:%02x\n"
"MTU=%d\n"
"[Transfer Details]\n"
"Bytes Received=%.0lf (%.2fMiB)\n"
"Bytes Sent=%.0lf (%.2fMiB)\n",
iface_type,
ni.mac[0], ni.mac[1],
ni.mac[2], ni.mac[3],
ni.mac[4], ni.mac[5],
ni.mtu,
recv_bytes, recv_mb,
trans_bytes, trans_mb);
#ifdef HAS_LINUX_WE
if (ni.is_wireless) {
gchar *txpower;
if (ni.wi_has_txpower) {
gint mw, dbm;
if (ni.wi_txpower.flags & IW_TXPOW_MWATT) {
mw = ni.wi_txpower.value;
dbm = (int) ceil(10.0 * log10((double) ni.wi_txpower.value));
} else {
dbm = ni.wi_txpower.value;
mw = (int) floor(pow(10.0, ((double) dbm / 10.0)));
}
txpower = g_strdup_printf("%ddBm (%dmW)", dbm, mw);
} else {
txpower = g_strdup("Unknown");
}
detailed = h_strdup_cprintf("\n[Wireless Properties]\n"
"Network Name (SSID)=%s\n"
"Bit Rate=%dMb/s\n"
"Transmission Power=%s\n"
"Mode=%s\n"
"Status=%d\n"
"Link Quality=%d\n"
"Signal / Noise=%d / %d\n",
detailed,
ni.wi_essid,
ni.wi_rate / 1000000,
txpower,
wi_operation_modes[ni.wi_mode],
ni.wi_status,
ni.wi_quality_level,
ni.wi_signal_level,
ni.wi_noise_level);
g_free(txpower);
}
#endif
if (ni.ip[0] || ni.mask[0] || ni.broadcast[0]) {
detailed =
h_strdup_cprintf("\n[Internet Protocol (IPv4)]\n"
"IP Address=%s\n" "Mask=%s\n"
"Broadcast Address=%s\n", detailed,
ni.ip[0] ? ni.ip : "Not set",
ni.mask[0] ? ni.mask : "Not set",
ni.broadcast[0] ? ni.
broadcast : "Not set");
}
g_hash_table_insert(moreinfo, devid, detailed);
}
}
fclose(proc_net);
}
gboolean __scan_udisks2_devices(void) {
GSList *node, *drives;
udiskd *disk;
gchar *udisks2_storage_list = NULL, *features = NULL, *moreinfo = NULL;
gchar *devid, *label;
const gchar *url, *vendor_str, *icon;
int n = 0, i;
static struct {
char *media_prefix;
char *icon;
} media2icon[] = {
{ "thumb", "usbfldisk"},
{ "flash", "usbfldisk"},
{ "floppy", "media-floppy"},
{ "optical", "cdrom"},
{ NULL, NULL}
};
moreinfo_del_with_prefix("DEV:UDISKS");
udisks2_storage_list = g_strdup(_("\n[UDisks2]\n"));
drives = get_udisks2_all_drives_info();
for (node = drives; node != NULL; node = node->next) {
disk = (udiskd *)node->data;
devid = g_strdup_printf("UDISKS%d", n++);
if (disk->vendor && strlen(disk->vendor) > 0) {
label = g_strdup_printf("%s %s", disk->vendor, disk->model);
vendor_str = disk->vendor;
}
else{
label = g_strdup(disk->model);
vendor_str = disk->model;
}
icon = NULL;
if (disk->media_compatibility){
for (i = 0; media2icon[i].media_prefix != NULL; i++) {
if (g_str_has_prefix(disk->media_compatibility,
media2icon[i].media_prefix)) {
icon = media2icon[i].icon;
break;
}
}
}
if (icon == NULL && disk->ejectable && g_strcmp0(disk->connection_bus, "usb") == 0) {
icon = "usbfldisk";
}
if (icon == NULL){
icon = "hdd";
}
url = vendor_get_url(vendor_str);
udisks2_storage_list = h_strdup_cprintf("$%s$%s=\n", udisks2_storage_list, devid, label);
storage_icons = h_strdup_cprintf("Icon$%s$%s=%s.png\n", storage_icons, devid, label, icon);
features = h_strdup_cprintf("%s", features, disk->removable ? _("Removable"): _("Fixed"));
if (disk->ejectable) {
features = h_strdup_cprintf(", %s", features, _("Ejectable"));
}
if (disk->smart_enabled) {
features = h_strdup_cprintf(", %s", features, _("Smart monitoring"));
}
moreinfo = g_strdup_printf(_("[Drive Information]\n"
"Model=%s\n"),
label);
if (url) {
moreinfo = h_strdup_cprintf(_("Vendor=%s (%s)\n"),
moreinfo,
vendor_get_name(vendor_str),
url);
}
else {
moreinfo = h_strdup_cprintf(_("Vendor=%s\n"),
moreinfo,
vendor_get_name(vendor_str));
}
moreinfo = h_strdup_cprintf(_("Revision=%s\n"
"Block Device=%s\n"
"Serial=%s\n"
"Size=%s\n"
"Features=%s\n"),
moreinfo,
disk->revision,
disk->block_dev,
disk->serial,
size_human_readable((gfloat) disk->size),
features);
if (disk->rotation_rate > 0) {
moreinfo = h_strdup_cprintf(_("Rotation Rate=%d\n"), moreinfo, disk->rotation_rate);
}
if (disk->media_compatibility || disk->media) {
moreinfo = h_strdup_cprintf(_("Media=%s\n"
"Media compatibility=%s\n"),
moreinfo,
disk->media ? disk->media : _("(None)"),
disk->media_compatibility ? disk->media_compatibility : _("(Unknown)"));
}
if (disk->connection_bus && strlen(disk->connection_bus) > 0) {
moreinfo = h_strdup_cprintf(_("Connection bus=%s\n"), moreinfo, disk->connection_bus);
}
if (disk->smart_enabled) {
moreinfo = h_strdup_cprintf(_("[Smart monitoring]\n"
"Status=%s\n"
"Bad Sectors=%ld\n"
"Power on time=%d days %d hours\n"
"Temperature=%d°C\n"),
moreinfo,
disk->smart_failing ? _("Failing"): _("OK"),
disk->smart_bad_sectors,
disk->smart_poweron/(60*60*24), (disk->smart_poweron/60/60) % 24,
disk->smart_temperature);
}
moreinfo_add_with_prefix("DEV", devid, moreinfo);
g_free(devid);
g_free(features);
g_free(label);
features = NULL;
moreinfo = NULL;
devid = NULL;
udiskd_free(disk);
}
g_slist_free(drives);
if (n) {
storage_list = h_strconcat(storage_list, udisks2_storage_list, NULL);
g_free(udisks2_storage_list);
return TRUE;
}
g_free(udisks2_storage_list);
return FALSE;
}
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 */
moreinfo_del_with_prefix("DEV:IDE");
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");
if (!proc_ide)
continue;
(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");
if (!proc_ide) {
free(model);
continue;
}
(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");
if (proc_ide) {
(void) fscanf(proc_ide, "%d", &cache);
fclose(proc_ide);
} else {
cache = 0;
}
}
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");
if (proc_ide) {
(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);
} else {
pgeometry = g_strdup("Unknown");
lgeometry = g_strdup("Unknown");
}
}
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;
}
moreinfo_add_with_prefix("DEV", devid, strhash);
g_free(devid);
g_free(model);
} else {
g_free(device);
}
iface++;
}
if (n) {
storage_list = h_strconcat(storage_list, ide_storage_list, NULL);
g_free(ide_storage_list);
}
}
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);
moreinfo_add_with_prefix("DEV", tmp, strhash);
g_free(tmp);
g_free(manufacturer);
g_free(product);
g_free(mxpwr);
}
/* SCSI support by Pascal F.Martin <*****@*****.**> */
void __scan_scsi_devices(void)
{
FILE *proc_scsi;
gchar buffer[256], *buf;
gint n = 0;
gint scsi_controller = 0;
gint scsi_channel = 0;
gint scsi_id = 0 ;
gint scsi_lun = 0;
gchar *vendor = NULL, *revision = NULL, *model = NULL;
gchar *scsi_storage_list;
/* remove old devices from global device table */
moreinfo_del_with_prefix("DEV:SCSI");
scsi_storage_list = g_strdup(_("\n[SCSI Disks]\n"));
int otype = 0;
if (proc_scsi = fopen("/proc/scsi/scsi", "r")) {
otype = 1;
} else if (proc_scsi = popen("lsscsi -c", "r")) {
otype = 2;
}
if (otype) {
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 (model && 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);
moreinfo_add_with_prefix("DEV", devid, strhash);
g_free(devid);
g_free(model);
g_free(revision);
g_free(vendor);
scsi_controller = scsi_channel = scsi_id = scsi_lun = 0;
}
}
if (otype == 1)
fclose(proc_scsi);
else if (otype == 2)
pclose(proc_scsi);
}
if (n) {
storage_list = h_strconcat(storage_list, scsi_storage_list, NULL);
g_free(scsi_storage_list);
}
}
gboolean __scan_usb_procfs(void)
{
FILE *dev;
gchar buffer[128];
gchar *tmp, *manuf = NULL, *product = NULL, *mxpwr;
gint bus, level, port = 0, classid = 0, 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) {
moreinfo_del_with_prefix("DEV:USB");
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 && *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);
moreinfo_add_with_prefix("DEV", tmp, strhash);
g_free(tmp);
}
g_free(manuf);
g_free(product);
manuf = g_strdup("");
product = g_strdup("");
port = classid = 0;
}
}
fclose(dev);
return n > 0;
}
void __scan_usb_lsusb_add_device(char *buffer, int bufsize, FILE *lsusb, int usb_device_number)
{
gint bus, device, vendor_id, product_id;
gchar *version = NULL, *product = NULL, *vendor = NULL, *dev_class = NULL, *int_class = NULL;
gchar *max_power = NULL, *name=NULL;
gchar *tmp, *strhash;
long position;
g_strstrip(buffer);
sscanf(buffer, "Bus %d Device %d: ID %x:%x",
&bus, &device, &vendor_id, &product_id);
name = g_strdup (buffer + 33);
for (fgets(buffer, bufsize, lsusb); fgets(buffer, bufsize, lsusb); position = ftell(lsusb)) {
g_strstrip(buffer);
if (g_str_has_prefix(buffer, "idVendor")) {
g_free(vendor);
vendor = g_strdup(buffer + 26);
} else if (g_str_has_prefix(buffer, "idProduct")) {
g_free(product);
product = g_strdup(buffer + 26);
} else if (g_str_has_prefix(buffer, "MaxPower")) {
g_free(max_power);
max_power = g_strdup(buffer + 9);
} else if (g_str_has_prefix(buffer, "bcdUSB")) {
g_free(version);
version = g_strdup(buffer + 7);
} else if (g_str_has_prefix(buffer, "bDeviceClass")) {
g_free(dev_class);
dev_class = g_strdup(buffer + 14);
} else if (g_str_has_prefix(buffer, "bInterfaceClass")) {
g_free(int_class);
int_class = g_strdup(buffer + 16);
} else if (g_str_has_prefix(buffer, "Bus ")) {
/* device separator */
fseek(lsusb, position, SEEK_SET);
break;
}
}
if (dev_class && strstr(dev_class, "0 (Defined at Interface level)")) {
g_free(dev_class);
if (int_class) {
dev_class = int_class;
} else {
dev_class = g_strdup("Unknown");
}
} else dev_class = g_strdup("Unknown");
tmp = g_strdup_printf("USB%d", usb_device_number);
usb_list = h_strdup_cprintf("$%s$%s=\n", usb_list, tmp, name);
strhash = g_strdup_printf("[Device Information]\n"
"Product=%s\n"
"Manufacturer=%s\n"
"Max Current=%s\n"
"[Misc]\n"
"USB Version=%s\n"
"Class=%s\n"
"Vendor=0x%x\n"
"Product ID=0x%x\n"
"Bus=%d\n",
product ? g_strstrip(product) : "Unknown",
vendor ? g_strstrip(vendor) : "Unknown",
max_power ? g_strstrip(max_power) : "Unknown",
version ? g_strstrip(version) : "Unknown",
dev_class ? g_strstrip(dev_class) : "Unknown",
vendor_id, product_id, bus);
moreinfo_add_with_prefix("DEV", tmp, strhash);
g_free(vendor);
g_free(product);
g_free(max_power);
g_free(dev_class);
g_free(version);
g_free(tmp);
g_free(name);
}
static void report_text_subsubtitle(ReportContext * ctx, gchar * text)
{
ctx->output = h_strdup_cprintf("-%s-\n", ctx->output, text);
}
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) {
moreinfo_add_with_prefix("DEV", strhash, strdevice);
g_free(strhash);
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 */
moreinfo_add_with_prefix("DEV", strhash, strdevice);
g_free(strhash);
g_free(category);
g_free(name);
}
g_free(lspci_path);
g_free(command_line);
}
void
scan_filesystems(void)
{
FILE *mtab;
gchar buf[1024];
struct statfs sfs;
int count = 0;
g_free(fs_list);
fs_list = g_strdup("");
moreinfo_del_with_prefix("COMP:FS");
mtab = fopen("/etc/mtab", "r");
if (!mtab)
return;
while (fgets(buf, 1024, mtab)) {
gfloat size, used, avail;
gchar **tmp;
tmp = g_strsplit(buf, " ", 0);
if (!statfs(tmp[1], &sfs)) {
gfloat use_ratio;
size = (float) sfs.f_bsize * (float) sfs.f_blocks;
avail = (float) sfs.f_bsize * (float) sfs.f_bavail;
used = size - avail;
if (size == 0.0f) {
continue;
}
if (avail == 0.0f) {
use_ratio = 100.0f;
} else {
use_ratio = 100.0f * (used / size);
}
gchar *strsize = size_human_readable(size),
*stravail = size_human_readable(avail),
*strused = size_human_readable(used);
gchar *strhash;
strreplacechr(tmp[0], "#", '_');
strhash = g_strdup_printf("[%s]\n"
"Filesystem=%s\n"
"Mounted As=%s\n"
"Mount Point=%s\n"
"Size=%s\n"
"Used=%s\n"
"Available=%s\n",
tmp[0],
tmp[2],
strstr(tmp[3], "rw") ? "Read-Write" :
"Read-Only", tmp[1], strsize, strused,
stravail);
gchar *key = g_strdup_printf("FS%d", ++count);
moreinfo_add_with_prefix("COMP", key, strhash);
g_free(key);
fs_list = h_strdup_cprintf("$FS%d$%s=%.2f %% (%s of %s)|%s\n",
fs_list,
count, tmp[0], use_ratio, stravail, strsize, tmp[1]);
g_free(strsize);
g_free(stravail);
g_free(strused);
}
g_strfreev(tmp);
}
fclose(mtab);
}
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);
}
}
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
__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")) {
if (remaining && capacity)
charge_rate = atof(remaining) / atof(capacity);
else
charge_rate = 0;
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 = manufacturer = NULL;
}
g_dir_close(acpi);
}
}
g_free(acpi_path);
}
void scan_dev(gboolean reload)
{
SCAN_START();
int i;
struct {
gchar *compiler_name;
gchar *version_command;
gchar *regex;
gboolean stdout;
} detect_lang[] = {
{ "Scripting Languages", NULL, FALSE },
{ "CPython", "python -V", "\\d+\\.\\d+\\.\\d+", FALSE },
{ "Perl", "perl -v", "\\d+\\.\\d+\\.\\d+", TRUE },
{ "PHP", "php --version", "\\d+\\.\\d+\\.\\S+", TRUE},
{ "Ruby", "ruby --version", "\\d+\\.\\d+\\.\\d+", TRUE },
{ "Bash", "bash --version", "\\d+\\.\\d+\\.\\S+", TRUE},
{ "Compilers", NULL, FALSE },
{ "C (GCC)", "gcc -v", "\\d+\\.\\d+\\.\\d+", FALSE },
{ "Java", "javac -version", "\\d+\\.\\d+\\.\\d+", FALSE },
{ "CSharp (Mono, old)", "mcs --version", "\\d+\\.\\d+\\.\\d+\\.\\d+", TRUE },
{ "CSharp (Mono)", "gmcs --version", "\\d+\\.\\d+\\.\\d+\\.\\d+", TRUE },
{ "Vala", "valac --version", "\\d+\\.\\d+\\.\\d+", TRUE },
{ "Haskell (GHC)", "ghc -v", "\\d+\\.\\d+\\.\\d+", FALSE },
{ "FreePascal", "fpc --version", "\\d+\\.\\d+\\.\\S+", TRUE },
{ "Tools", NULL, FALSE },
{ "make", "make --version", "\\d+\\.\\d+", TRUE },
{ "GDB", "gdb --version", "\\d+\\.\\S+", TRUE },
{ "strace", "strace -V", "\\d+\\.\\d+\\.\\d+", TRUE },
{ "valgrind", "valgrind --version", "\\d+\\.\\d+\\.\\S+", TRUE },
{ "QMake", "qmake --version", "\\d+\\.\\S+", TRUE},
};
g_free(dev_list);
dev_list = g_strdup("");
for (i = 0; i < G_N_ELEMENTS(detect_lang); i++) {
gchar *version = NULL;
gchar *output;
gchar *temp;
GRegex *regex;
GMatchInfo *match_info;
gboolean found;
if (!detect_lang[i].regex) {
dev_list = h_strdup_cprintf("[%s]\n", dev_list, detect_lang[i].compiler_name);
continue;
}
if (detect_lang[i].stdout) {
found = g_spawn_command_line_sync(detect_lang[i].version_command, &output, NULL, NULL, NULL);
} else {
found = g_spawn_command_line_sync(detect_lang[i].version_command, NULL, &output, NULL, NULL);
}
if (found) {
regex = g_regex_new(detect_lang[i].regex, 0, 0, NULL);
g_regex_match(regex, output, 0, &match_info);
if (g_match_info_matches(match_info)) {
version = g_match_info_fetch(match_info, 0);
}
g_match_info_free(match_info);
g_regex_unref(regex);
g_free(output);
}
if (version) {
dev_list = h_strdup_cprintf("%s=%s\n", dev_list, detect_lang[i].compiler_name, version);
g_free(version);
} else {
dev_list = h_strdup_cprintf("%s=Not found\n", dev_list, detect_lang[i].compiler_name);
}
temp = g_strdup_printf("Detecting version: %s",
detect_lang[i].compiler_name);
shell_status_update(temp);
g_free(temp);
}
SCAN_END();
}
