fallingsky04
/
slstatus
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use indentation to increase readability 

Granted, this style is definitely not common, but for the short
utility-functions of this program it's just the right choice. This
provides great flexibility, such that in the long run, it will be
possible to also share code between the OS-implementations.

This also keeps the state-keeping at a minimum and makes it clearer
which functions are implemented on which OS without having to jiggle
around with too many files in the process.
This commit is contained in:
Laslo Hunhold 2018-05-01 19:01:22 +02:00 committed by Aaron Marcher
parent 42edfea89a
commit 9750a3d731
9 changed files with 556 additions and 522 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
LICENSE
View File

@ -11,7 +11,7 @@ Copyright 2016-2017 Quentin Rameau <quinq@fifth.space>
Copyright 2016 Mike Coddington <mike@coddington.us> Copyright 2016 Mike Coddington <mike@coddington.us>
Copyright 2016-2018 parazyd <parazyd@dyne.org> Copyright 2016-2018 parazyd <parazyd@dyne.org>
Copyright 2017 Tobias Stoeckmann <tobias@stoeckmann.org> Copyright 2017 Tobias Stoeckmann <tobias@stoeckmann.org>
Copyright 2017 Laslo Hunhold <dev@frign.de> Copyright 2017-2018 Laslo Hunhold <dev@frign.de>
Copyright 2018 Darron Anderson <darronanderson@protonmail.com> Copyright 2018 Darron Anderson <darronanderson@protonmail.com>
Permission to use, copy, modify, and/or distribute this software for any Permission to use, copy, modify, and/or distribute this software for any

146
components/battery.c
View File

@ -2,90 +2,90 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#if defined(__linux__)
#include <limits.h>
#include <string.h>
#elif defined(__OpenBSD__)
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <machine/apmvar.h>
#endif
#include "../util.h" #include "../util.h"
#if defined(__linux__) #if defined(__linux__)
const char * #include <limits.h>
battery_perc(const char *bat)
{
int perc;
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/", bat, "/capacity"); const char *
return (pscanf(path, "%i", &perc) == 1) ? battery_perc(const char *bat)
bprintf("%d", perc) : NULL; {
} int perc;
#elif defined(__OpenBSD__) char path[PATH_MAX];
const char *
battery_perc(const char *null)
{
struct apm_power_info apm_info;
int fd;
fd = open("/dev/apm", O_RDONLY); snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/",
if (fd < 0) { bat, "/capacity");
fprintf(stderr, "open '/dev/apm': %s\n", strerror(errno)); return (pscanf(path, "%i", &perc) == 1) ?
return NULL; bprintf("%d", perc) : NULL;
} }
if (ioctl(fd, APM_IOC_GETPOWER, &apm_info) < 0) { const char *
fprintf(stderr, "ioctl 'APM_IOC_GETPOWER': %s\n", strerror(errno)); battery_power(const char *bat)
close(fd); {
return NULL; int watts;
} char path[PATH_MAX];
close(fd);
return bprintf("%d", apm_info.battery_life); snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/",
} bat, "/power_now");
#endif return (pscanf(path, "%i", &watts) == 1) ?
bprintf("%d", (watts + 500000) / 1000000) : NULL;
#if defined(__linux__)
const char *
battery_power(const char *bat)
{
int watts;
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/", bat, "/power_now");
return (pscanf(path, "%i", &watts) == 1) ?
bprintf("%d", (watts + 500000) / 1000000) : NULL;
}
const char *
battery_state(const char *bat)
{
struct {
char *state;
char *symbol;
} map[] = {
{ "Charging", "+" },
{ "Discharging", "-" },
{ "Full", "=" },
{ "Unknown", "/" },
};
size_t i;
char path[PATH_MAX], state[12];
snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/", bat, "/status");
if (pscanf(path, "%12s", state) != 1) {
return NULL;
} }
for (i = 0; i < LEN(map); i++) { const char *
if (!strcmp(map[i].state, state)) { battery_state(const char *bat)
break; {
struct {
char *state;
char *symbol;
} map[] = {
{ "Charging", "+" },
{ "Discharging", "-" },
{ "Full", "=" },
{ "Unknown", "/" },
};
size_t i;
char path[PATH_MAX], state[12];
snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/",
bat, "/status");
if (pscanf(path, "%12s", state) != 1) {
return NULL;
} }
for (i = 0; i < LEN(map); i++) {
if (!strcmp(map[i].state, state)) {
break;
}
}
return (i == LEN(map)) ? "?" : map[i].symbol;
}
#elif defined(__OpenBSD__)
#include <fcntl.h>
#include <machine/apmvar.h>
#include <sys/ioctl.h>
#include <unistd.h>
const char *
battery_perc(const char *null)
{
struct apm_power_info apm_info;
int fd;
fd = open("/dev/apm", O_RDONLY);
if (fd < 0) {
fprintf(stderr, "open '/dev/apm': %s\n", strerror(errno));
return NULL;
}
if (ioctl(fd, APM_IOC_GETPOWER, &apm_info) < 0) {
fprintf(stderr, "ioctl 'APM_IOC_GETPOWER': %s\n",
strerror(errno));
close(fd);
return NULL;
}
close(fd);
return bprintf("%d", apm_info.battery_life);
} }
return (i == LEN(map)) ? "?" : map[i].symbol;
}
#endif #endif

134
components/cpu.c
View File

@ -2,87 +2,91 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#if defined(__OpenBSD__)
#include <sys/sysctl.h>
#endif
#include "../util.h" #include "../util.h"
#if defined(__linux__) #if defined(__linux__)
const char * const char *
cpu_freq(void) cpu_freq(void)
{ {
int freq; int freq;
return (pscanf("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", return (pscanf("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq",
"%i", &freq) == 1) ? "%i", &freq) == 1) ?
bprintf("%d", (freq + 500) / 1000) : NULL; bprintf("%d", (freq + 500) / 1000) : NULL;
}
const char *
cpu_perc(void)
{
int perc;
static long double a[7];
static int valid;
long double b[7];
memcpy(b, a, sizeof(b));
if (pscanf("/proc/stat", "%*s %Lf %Lf %Lf %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2],
&a[3], &a[4], &a[5], &a[6]) != 7) {
return NULL;
}
if (!valid) {
valid = 1;
return NULL;
} }
perc = 100 * ((b[0]+b[1]+b[2]+b[5]+b[6]) - (a[0]+a[1]+a[2]+a[5]+a[6])) / const char *
((b[0]+b[1]+b[2]+b[3]+b[4]+b[5]+b[6]) - (a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6])); cpu_perc(void)
{
int perc;
static long double a[7];
static int valid;
long double b[7];
return bprintf("%d", perc); memcpy(b, a, sizeof(b));
} if (pscanf("/proc/stat", "%*s %Lf %Lf %Lf %Lf %Lf %Lf %Lf",
&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6]) != 7) {
return NULL;
}
if (!valid) {
valid = 1;
return NULL;
}
const char * perc = 100 *
cpu_iowait(void) ((b[0]+b[1]+b[2]+b[5]+b[6]) -
{ (a[0]+a[1]+a[2]+a[5]+a[6])) /
int perc; ((b[0]+b[1]+b[2]+b[3]+b[4]+b[5]+b[6]) -
static int valid; (a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]));
static long double a[7];
long double b[7];
memcpy(b, a, sizeof(b)); return bprintf("%d", perc);
if (pscanf("/proc/stat", "%*s %Lf %Lf %Lf %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2],
&a[3], &a[4], &a[5], &a[6]) != 7) {
return NULL;
}
if (!valid) {
valid = 1;
return NULL;
} }
perc = 100 * ((b[4]) - (a[4])) / const char *
((b[0]+b[1]+b[2]+b[3]+b[4]+b[5]+b[6]) - (a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6])); cpu_iowait(void)
{
int perc;
static int valid;
static long double a[7];
long double b[7];
return bprintf("%d", perc); memcpy(b, a, sizeof(b));
} if (pscanf("/proc/stat", "%*s %Lf %Lf %Lf %Lf %Lf %Lf %Lf",
&a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6]) != 7) {
return NULL;
}
if (!valid) {
valid = 1;
return NULL;
}
perc = 100 * ((b[4]) - (a[4])) /
((b[0]+b[1]+b[2]+b[3]+b[4]+b[5]+b[6]) -
(a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]));
return bprintf("%d", perc);
}
#elif defined(__OpenBSD__) #elif defined(__OpenBSD__)
const char * #include <sys/sysctl.h>
cpu_freq(void)
{
int freq, mib[2];
size_t size;
mib[0] = CTL_HW; const char *
mib[1] = HW_CPUSPEED; cpu_freq(void)
{
int freq, mib[2];
size_t size;
size = sizeof(freq); mib[0] = CTL_HW;
mib[1] = HW_CPUSPEED;
if (sysctl(mib, 2, &freq, &size, NULL, 0) == -1) { size = sizeof(freq);
fprintf(stderr, "sysctl 'HW_CPUSPEED': %s\n", strerror(errno));
return NULL; if (sysctl(mib, 2, &freq, &size, NULL, 0) == -1) {
fprintf(stderr, "sysctl 'HW_CPUSPEED': %s\n",
strerror(errno));
return NULL;
}
return bprintf("%d", freq);
} }
return bprintf("%d", freq);
}
#endif #endif

21
components/entropy.c
View File

@ -1,15 +1,18 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#if defined(__linux__) #if defined(__linux__)
#include <stdio.h> #include <stdio.h>
#include "../util.h" #include "../util.h"
const char * const char *
entropy(void) entropy(void)
{ {
int num; int num;
return (pscanf("/proc/sys/kernel/random/entropy_avail", "%d", &num) == 1) ? return (pscanf("/proc/sys/kernel/random/entropy_avail",
bprintf("%d", num) : NULL; "%d", &num) == 1) ?
} bprintf("%d", num) : NULL;
}
#elif defined(__OpenBSD__)
/* unimplemented */
#endif #endif

198
components/ram.c
View File

@ -1,129 +1,133 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#include <stdio.h> #include <stdio.h>
#if defined (__OpenBSD__)
#include <sys/types.h>
#include <sys/sysctl.h>
#include <stdlib.h>
#include <unistd.h>
#endif
#include "../util.h" #include "../util.h"
#if defined(__linux__) #if defined(__linux__)
const char * const char *
ram_free(void) ram_free(void)
{ {
long free; long free;
return (pscanf("/proc/meminfo", "MemFree: %ld kB\n", &free) == 1) ? return (pscanf("/proc/meminfo", "MemFree: %ld kB\n", &free) == 1) ?
bprintf("%f", (float)free / 1024 / 1024) : NULL; bprintf("%f", (float)free / 1024 / 1024) : NULL;
} }
const char * const char *
ram_perc(void) ram_perc(void)
{ {
long total, free, buffers, cached; long total, free, buffers, cached;
return (pscanf("/proc/meminfo", return (pscanf("/proc/meminfo",
"MemTotal: %ld kB\n" "MemTotal: %ld kB\n"
"MemFree: %ld kB\n" "MemFree: %ld kB\n"
"MemAvailable: %ld kB\nBuffers: %ld kB\n" "MemAvailable: %ld kB\nBuffers: %ld kB\n"
"Cached: %ld kB\n", "Cached: %ld kB\n",
&total, &free, &buffers, &buffers, &cached) == 5) ? &total, &free, &buffers, &buffers, &cached) == 5) ?
bprintf("%d", 100 * ((total - free) - (buffers + cached)) / total) : bprintf("%d", 100 * ((total - free) - (buffers + cached)) /
NULL; total) :
} NULL;
}
const char * const char *
ram_total(void) ram_total(void)
{ {
long total; long total;
return (pscanf("/proc/meminfo", "MemTotal: %ld kB\n", &total) == 1) ? return (pscanf("/proc/meminfo", "MemTotal: %ld kB\n", &total) == 1) ?
bprintf("%f", (float)total / 1024 / 1024) : NULL; bprintf("%f", (float)total / 1024 / 1024) : NULL;
} }
const char * const char *
ram_used(void) ram_used(void)
{ {
long total, free, buffers, cached; long total, free, buffers, cached;
return (pscanf("/proc/meminfo", return (pscanf("/proc/meminfo",
"MemTotal: %ld kB\n" "MemTotal: %ld kB\n"
"MemFree: %ld kB\n" "MemFree: %ld kB\n"
"MemAvailable: %ld kB\nBuffers: %ld kB\n" "MemAvailable: %ld kB\nBuffers: %ld kB\n"
"Cached: %ld kB\n", "Cached: %ld kB\n",
&total, &free, &buffers, &buffers, &cached) == 5) ? &total, &free, &buffers, &buffers, &cached) == 5) ?
bprintf("%f", (float)(total - free - buffers - cached) / 1024 / 1024) : bprintf("%f", (float)(total - free - buffers - cached) /
NULL; 1024 / 1024) :
} NULL;
}
#elif defined(__OpenBSD__) #elif defined(__OpenBSD__)
inline int #include <sys/types.h>
load_uvmexp(struct uvmexp *uvmexp) #include <sys/sysctl.h>
{ #include <stdlib.h>
int uvmexp_mib[] = {CTL_VM, VM_UVMEXP}; #include <unistd.h>
size_t size;
size = sizeof(*uvmexp); inline int
load_uvmexp(struct uvmexp *uvmexp)
{
int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
size_t size;
return sysctl(uvmexp_mib, 2, uvmexp, &size, NULL, 0) >= 0 ? 1 : 0; size = sizeof(*uvmexp);
}
const char * return sysctl(uvmexp_mib, 2, uvmexp, &size, NULL, 0) >= 0 ? 1 : 0;
ram_free(void)
{
struct uvmexp uvmexp;
float free;
int free_pages;
if (load_uvmexp(&uvmexp)) {
free_pages = uvmexp.npages - uvmexp.active;
free = (double) (free_pages * uvmexp.pagesize) / 1024 / 1024 / 1024;
return bprintf("%f", free);
} }
return NULL; const char *
} ram_free(void)
{
struct uvmexp uvmexp;
float free;
int free_pages;
const char * if (load_uvmexp(&uvmexp)) {
ram_perc(void) free_pages = uvmexp.npages - uvmexp.active;
{ free = (double) (free_pages * uvmexp.pagesize) / 1024 /
struct uvmexp uvmexp; 1024 / 1024;
int percent; return bprintf("%f", free);
}
if (load_uvmexp(&uvmexp)) { return NULL;
percent = uvmexp.active * 100 / uvmexp.npages;
return bprintf("%d", percent);
} }
return NULL; const char *
} ram_perc(void)
{
struct uvmexp uvmexp;
int percent;
const char * if (load_uvmexp(&uvmexp)) {
ram_total(void) percent = uvmexp.active * 100 / uvmexp.npages;
{ return bprintf("%d", percent);
struct uvmexp uvmexp; }
float total;
if (load_uvmexp(&uvmexp)) { return NULL;
total = (double) (uvmexp.npages * uvmexp.pagesize) / 1024 / 1024 / 1024;
return bprintf("%f", total);
} }
return NULL; const char *
} ram_total(void)
{
struct uvmexp uvmexp;
float total;
const char * if (load_uvmexp(&uvmexp)) {
ram_used(void) total = (double) (uvmexp.npages * uvmexp.pagesize) /
{ 1024 / 1024 / 1024;
struct uvmexp uvmexp; return bprintf("%f", total);
float used; }
if (load_uvmexp(&uvmexp)) { return NULL;
used = (double) (uvmexp.active * uvmexp.pagesize) / 1024 / 1024 / 1024;
return bprintf("%f", used);
} }
return NULL; const char *
} ram_used(void)
{
struct uvmexp uvmexp;
float used;
if (load_uvmexp(&uvmexp)) {
used = (double) (uvmexp.active * uvmexp.pagesize) /
1024 / 1024 / 1024;
return bprintf("%f", used);
}
return NULL;
}
#endif #endif

244
components/swap.c
View File

@ -1,138 +1,152 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#if defined(__linux__) #if defined(__linux__)
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "../util.h" #include "../util.h"
const char * const char *
swap_free(void) swap_free(void)
{ {
long total, free; long total, free;
FILE *fp; FILE *fp;
size_t bytes_read; size_t bytes_read;
char *match; char *match;
fp = fopen("/proc/meminfo", "r"); fp = fopen("/proc/meminfo", "r");
if (fp == NULL) { if (fp == NULL) {
fprintf(stderr, "fopen '/proc/meminfo': %s\n", strerror(errno)); fprintf(stderr, "fopen '/proc/meminfo': %s\n",
return NULL; strerror(errno));
} return NULL;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) { if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1,
fprintf(stderr, "fread '/proc/meminfo': %s\n", strerror(errno)); fp)) == 0) {
fprintf(stderr, "fread '/proc/meminfo': %s\n",
strerror(errno));
fclose(fp);
return NULL;
}
fclose(fp); fclose(fp);
return NULL;
}
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL; return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total); sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapFree")) == NULL) if ((match = strstr(buf, "SwapFree")) == NULL)
return NULL; return NULL;
sscanf(match, "SwapFree: %ld kB\n", &free); sscanf(match, "SwapFree: %ld kB\n", &free);
return bprintf("%f", (float)free / 1024 / 1024); return bprintf("%f", (float)free / 1024 / 1024);
}
const char *
swap_perc(void)
{
long total, free, cached;
FILE *fp;
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
fprintf(stderr, "fopen '/proc/meminfo': %s\n", strerror(errno));
return NULL;
} }
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) { const char *
fprintf(stderr, "fread '/proc/meminfo': %s\n", strerror(errno)); swap_perc(void)
{
long total, free, cached;
FILE *fp;
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
fprintf(stderr, "fopen '/proc/meminfo': %s\n",
strerror(errno));
return NULL;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1,
fp)) == 0) {
fprintf(stderr, "fread '/proc/meminfo': %s\n",
strerror(errno));
fclose(fp);
return NULL;
}
fclose(fp); fclose(fp);
return NULL;
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapCached")) == NULL)
return NULL;
sscanf(match, "SwapCached: %ld kB\n", &cached);
if ((match = strstr(buf, "SwapFree")) == NULL)
return NULL;
sscanf(match, "SwapFree: %ld kB\n", &free);
return bprintf("%d", 100 * (total - free - cached) / total);
} }
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) const char *
return NULL; swap_total(void)
sscanf(match, "SwapTotal: %ld kB\n", &total); {
long total;
FILE *fp;
size_t bytes_read;
char *match;
if ((match = strstr(buf, "SwapCached")) == NULL) fp = fopen("/proc/meminfo", "r");
return NULL; if (fp == NULL) {
sscanf(match, "SwapCached: %ld kB\n", &cached); fprintf(stderr, "fopen '/proc/meminfo': %s\n",
strerror(errno));
if ((match = strstr(buf, "SwapFree")) == NULL) return NULL;
return NULL; }
sscanf(match, "SwapFree: %ld kB\n", &free); if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1,
fp)) == 0) {
return bprintf("%d", 100 * (total - free - cached) / total); fprintf(stderr, "fread '/proc/meminfo': %s\n",
} strerror(errno));
fclose(fp);
const char * return NULL;
swap_total(void) }
{
long total;
FILE *fp;
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
fprintf(stderr, "fopen '/proc/meminfo': %s\n", strerror(errno));
return NULL;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) {
fprintf(stderr, "fread '/proc/meminfo': %s\n", strerror(errno));
fclose(fp); fclose(fp);
return NULL;
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
return bprintf("%f", (float)total / 1024 / 1024);
} }
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) const char *
return NULL; swap_used(void)
sscanf(match, "SwapTotal: %ld kB\n", &total); {
long total, free, cached;
FILE *fp;
size_t bytes_read;
char *match;
return bprintf("%f", (float)total / 1024 / 1024); fp = fopen("/proc/meminfo", "r");
} if (fp == NULL) {
fprintf(stderr, "fopen '/proc/meminfo': %s\n",
const char * strerror(errno));
swap_used(void) return NULL;
{ }
long total, free, cached; if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1,
FILE *fp; fp)) == 0) {
size_t bytes_read; fprintf(stderr, "fread '/proc/meminfo': %s\n",
char *match; strerror(errno));
fclose(fp);
fp = fopen("/proc/meminfo", "r"); return NULL;
if (fp == NULL) { }
fprintf(stderr, "fopen '/proc/meminfo': %s\n", strerror(errno));
return NULL;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) {
fprintf(stderr, "fread '/proc/meminfo': %s\n", strerror(errno));
fclose(fp); fclose(fp);
return NULL;
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapCached")) == NULL)
return NULL;
sscanf(match, "SwapCached: %ld kB\n", &cached);
if ((match = strstr(buf, "SwapFree")) == NULL)
return NULL;
sscanf(match, "SwapFree: %ld kB\n", &free);
return bprintf("%f", (float)(total - free - cached) / 1024 / 1024);
} }
fclose(fp); #elif defined(__OpenBSD__)
/* unimplemented */
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapCached")) == NULL)
return NULL;
sscanf(match, "SwapCached: %ld kB\n", &cached);
if ((match = strstr(buf, "SwapFree")) == NULL)
return NULL;
sscanf(match, "SwapFree: %ld kB\n", &free);
return bprintf("%f", (float)(total - free - cached) / 1024 / 1024);
}
#endif #endif

74
components/temperature.c
View File

@ -1,45 +1,47 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#include <errno.h> #include <stddef.h>
#include <stdio.h>
#include <string.h>
#if defined(__OpenBSD__)
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/sensors.h>
#endif
#include "../util.h" #include "../util.h"
#if defined(__linux__) #if defined(__linux__)
const char * const char *
temp(const char *file) temp(const char *file)
{ {
int temp; int temp;
return (pscanf(file, "%d", &temp) == 1) ? return (pscanf(file, "%d", &temp) == 1) ?
bprintf("%d", temp / 1000) : NULL; bprintf("%d", temp / 1000) : NULL;
}
#elif defined(__OpenBSD__)
const char *
temp(const char *null)
{
int mib[5];
size_t size;
struct sensor temp;
mib[0] = CTL_HW;
mib[1] = HW_SENSORS;
mib[2] = 0; /* cpu0 */
mib[3] = SENSOR_TEMP;
mib[4] = 0; /* temp0 */
size = sizeof(temp);
if (sysctl(mib, 5, &temp, &size, NULL, 0) == -1) {
fprintf(stderr, "sysctl 'SENSOR_TEMP': %s\n", strerror(errno));
return NULL;
} }
#elif defined(__OpenBSD__)
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <sys/sysctl.h>
#include <sys/time.h>
#include <sys/sensors.h>
return bprintf("%d", (temp.value - 273150000) / 1000000); /* kelvin to celsius */ const char *
} temp(const char *null)
{
int mib[5];
size_t size;
struct sensor temp;
mib[0] = CTL_HW;
mib[1] = HW_SENSORS;
mib[2] = 0; /* cpu0 */
mib[3] = SENSOR_TEMP;
mib[4] = 0; /* temp0 */
size = sizeof(temp);
if (sysctl(mib, 5, &temp, &size, NULL, 0) == -1) {
fprintf(stderr, "sysctl 'SENSOR_TEMP': %s\n",
strerror(errno));
return NULL;
}
/* kelvin to celsius */
return bprintf("%d", (temp.value - 273150000) / 1000000);
}
#endif #endif

93
components/uptime.c
View File

@ -2,62 +2,61 @@
#include <errno.h> #include <errno.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#if defined(__linux__)
#include <sys/sysinfo.h>
#elif defined(__OpenBSD__)
#include <sys/sysctl.h>
#include <sys/time.h>
#endif
#include "../util.h" #include "../util.h"
#if defined(__linux__) #if defined(__linux__)
const char * #include <sys/sysinfo.h>
uptime(void)
{
int h;
int m;
int uptime = 0;
struct sysinfo info;
sysinfo(&info); const char *
uptime = info.uptime; uptime(void)
{
int h;
int m;
int uptime = 0;
struct sysinfo info;
h = uptime / 3600; sysinfo(&info);
m = (uptime - h * 3600) / 60; uptime = info.uptime;
return bprintf("%dh %dm", h, m); h = uptime / 3600;
} m = (uptime - h * 3600) / 60;
#elif defined(__OpenBSD__)
const char *
uptime(void)
{
int h;
int m;
int uptime = 0;
int mib[2]; return bprintf("%dh %dm", h, m);
size_t size;
time_t now;
struct timeval boottime;
time(&now);
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
size = sizeof(boottime);
if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1)
uptime = now - boottime.tv_sec;
else {
fprintf(stderr, "sysctl 'KERN_BOOTTIME': %s\n", strerror(errno));
return NULL;
} }
#elif defined(__OpenBSD__)
#include <sys/sysctl.h>
#include <sys/time.h>
h = uptime / 3600; const char *
m = (uptime - h * 3600) / 60; uptime(void)
{
int h;
int m;
int uptime = 0;
return bprintf("%dh %dm", h, m); int mib[2];
} size_t size;
time_t now;
struct timeval boottime;
time(&now);
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
size = sizeof(boottime);
if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1)
uptime = now - boottime.tv_sec;
else {
fprintf(stderr, "sysctl 'KERN_BOOTTIME': %s\n", strerror(errno));
return NULL;
}
h = uptime / 3600;
m = (uptime - h * 3600) / 60;
return bprintf("%dh %dm", h, m);
}
#endif #endif

166
components/wifi.c
View File

@ -1,92 +1,100 @@
/* See LICENSE file for copyright and license details. */ /* See LICENSE file for copyright and license details. */
#if defined(__linux__) #if defined(__linux__)
#include <errno.h> #include <errno.h>
#include <ifaddrs.h> #include <ifaddrs.h>
#include <linux/wireless.h> #include <linux/wireless.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <stdio.h> #include <stdio.h>
#include <limits.h> #include <limits.h>
#include <string.h> #include <string.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <unistd.h> #include <unistd.h>
#include "../util.h" #include "../util.h"
const char * const char *
wifi_perc(const char *iface) wifi_perc(const char *iface)
{ {
int i, cur; int i, cur;
float perc; float perc;
int total = 70; /* the max of /proc/net/wireless */ int total = 70; /* the max of /proc/net/wireless */
char *p, *datastart; char *p, *datastart;
char path[PATH_MAX]; char path[PATH_MAX];
char status[5]; char status[5];
FILE *fp; FILE *fp;
snprintf(path, sizeof(path), "%s%s%s", "/sys/class/net/", iface, "/operstate"); snprintf(path, sizeof(path), "%s%s%s", "/sys/class/net/", iface,
fp = fopen(path, "r"); "/operstate");
if (fp == NULL) { fp = fopen(path, "r");
fprintf(stderr, "fopen '%s': %s\n", path, strerror(errno)); if (fp == NULL) {
return NULL; fprintf(stderr, "fopen '%s': %s\n", path,
} strerror(errno));
p = fgets(status, 5, fp); return NULL;
fclose(fp); }
if(!p || strcmp(status, "up\n") != 0) { p = fgets(status, 5, fp);
return NULL; fclose(fp);
if(!p || strcmp(status, "up\n") != 0) {
return NULL;
}
fp = fopen("/proc/net/wireless", "r");
if (fp == NULL) {
fprintf(stderr, "fopen '/proc/net/wireless': %s\n",
strerror(errno));
return NULL;
}
for (i = 0; i < 3; i++) {
if (!(p = fgets(buf, sizeof(buf) - 1, fp)))
break;
}
fclose(fp);
if (i < 2 || !p)
return NULL;
if ((datastart = strstr(buf, iface)) == NULL)
return NULL;
datastart = (datastart+(strlen(iface)+1));
sscanf(datastart + 1, " %*d %d %*d %*d\t\t %*d\t "
"%*d\t\t%*d\t\t %*d\t %*d\t\t %*d", &cur);
perc = (float)cur / total * 100.0;
return bprintf("%.0f", perc);
} }
fp = fopen("/proc/net/wireless", "r"); const char *
if (fp == NULL) { wifi_essid(const char *iface)
fprintf(stderr, "fopen '/proc/net/wireless': %s\n", strerror(errno)); {
return NULL; static char id[IW_ESSID_MAX_SIZE+1];
} int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
struct iwreq wreq;
for (i = 0; i < 3; i++) { memset(&wreq, 0, sizeof(struct iwreq));
if (!(p = fgets(buf, sizeof(buf) - 1, fp))) wreq.u.essid.length = IW_ESSID_MAX_SIZE+1;
break; snprintf(wreq.ifr_name, sizeof(wreq.ifr_name), "%s", iface);
}
fclose(fp);
if (i < 2 || !p)
return NULL;
if ((datastart = strstr(buf, iface)) == NULL) if (sockfd == -1) {
return NULL; fprintf(stderr, "socket 'AF_INET': %s\n",
strerror(errno));
return NULL;
}
wreq.u.essid.pointer = id;
if (ioctl(sockfd,SIOCGIWESSID, &wreq) == -1) {
fprintf(stderr, "ioctl 'SIOCGIWESSID': %s\n",
strerror(errno));
close(sockfd);
return NULL;
}
datastart = (datastart+(strlen(iface)+1));
sscanf(datastart + 1, " %*d %d %*d %*d %*d %*d %*d %*d %*d %*d", &cur);
perc = (float)cur / total * 100.0;
return bprintf("%.0f", perc);
}
const char *
wifi_essid(const char *iface)
{
static char id[IW_ESSID_MAX_SIZE+1];
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
struct iwreq wreq;
memset(&wreq, 0, sizeof(struct iwreq));
wreq.u.essid.length = IW_ESSID_MAX_SIZE+1;
snprintf(wreq.ifr_name, sizeof(wreq.ifr_name), "%s", iface);
if (sockfd == -1) {
fprintf(stderr, "socket 'AF_INET': %s\n", strerror(errno));
return NULL;
}
wreq.u.essid.pointer = id;
if (ioctl(sockfd,SIOCGIWESSID, &wreq) == -1) {
fprintf(stderr, "ioctl 'SIOCGIWESSID': %s\n", strerror(errno));
close(sockfd); close(sockfd);
return NULL;
if (strcmp(id, "") == 0)
return NULL;
else
return id;
} }
#elif defined(__OpenBSD__)
close(sockfd); /* unimplemented */
if (strcmp(id, "") == 0)
return NULL;
else
return id;
}
#endif #endif