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(); }