lhark
/
slstatus
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

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.
master
Laslo Hunhold 8 years ago
committed by Aaron Marcher
parent
42edfea89a
commit
9750a3d731
9 changed files with 573 additions and 539 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      LICENSE
  2. 138
      components/battery.c
  3. 136
      components/cpu.c
  4. 21
      components/entropy.c
  5. 220
      components/ram.c
  6. 260
      components/swap.c
  7. 76
      components/temperature.c
  8. 101
      components/uptime.c
  9. 158
      components/wifi.c

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

138
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];
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;
} }
close(fd);
return bprintf("%d", apm_info.battery_life); const char *
} battery_state(const char *bat)
#endif {
struct {
char *state;
char *symbol;
} map[] = {
{ "Charging", "+" },
{ "Discharging", "-" },
{ "Full", "=" },
{ "Unknown", "/" },
};
size_t i;
char path[PATH_MAX], state[12];
#if defined(__linux__) snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/",
const char * bat, "/status");
battery_power(const char *bat) if (pscanf(path, "%12s", state) != 1) {
{ return NULL;
int watts; }
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s%s%s", "/sys/class/power_supply/", bat, "/power_now"); for (i = 0; i < LEN(map); i++) {
return (pscanf(path, "%i", &watts) == 1) ? if (!strcmp(map[i].state, state)) {
bprintf("%d", (watts + 500000) / 1000000) : NULL; 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 * const char *
battery_state(const char *bat) battery_perc(const char *null)
{ {
struct { struct apm_power_info apm_info;
char *state; int fd;
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"); fd = open("/dev/apm", O_RDONLY);
if (pscanf(path, "%12s", state) != 1) { if (fd < 0) {
return NULL; fprintf(stderr, "open '/dev/apm': %s\n", strerror(errno));
} return NULL;
}
for (i = 0; i < LEN(map); i++) { if (ioctl(fd, APM_IOC_GETPOWER, &apm_info) < 0) {
if (!strcmp(map[i].state, state)) { fprintf(stderr, "ioctl 'APM_IOC_GETPOWER': %s\n",
break; strerror(errno));
close(fd);
return NULL;
} }
close(fd);
return bprintf("%d", apm_info.battery_life);
} }
return (i == LEN(map)) ? "?" : map[i].symbol;
}
#endif #endif

136
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];
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;
}
return bprintf("%d", perc); 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;
}
return bprintf("%d", freq); if (sysctl(mib, 2, &freq, &size, NULL, 0) == -1) {
} fprintf(stderr, "sysctl 'HW_CPUSPEED': %s\n",
strerror(errno));
return NULL;
}
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

220
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 *
ram_total(void) const char *
{ ram_total(void)
long total; {
long total;
return (pscanf("/proc/meminfo", "MemTotal: %ld kB\n", &total) == 1) ?
bprintf("%f", (float)total / 1024 / 1024) : NULL; return (pscanf("/proc/meminfo", "MemTotal: %ld kB\n", &total) == 1) ?
} bprintf("%f", (float)total / 1024 / 1024) : NULL;
const char *
ram_used(void)
{
long total, free, buffers, cached;
return (pscanf("/proc/meminfo",
"MemTotal: %ld kB\n"
"MemFree: %ld kB\n"
"MemAvailable: %ld kB\nBuffers: %ld kB\n"
"Cached: %ld kB\n",
&total, &free, &buffers, &buffers, &cached) == 5) ?
bprintf("%f", (float)(total - free - buffers - cached) / 1024 / 1024) :
NULL;
}
#elif defined(__OpenBSD__)
inline int
load_uvmexp(struct uvmexp *uvmexp)
{
int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
size_t size;
size = sizeof(*uvmexp);
return sysctl(uvmexp_mib, 2, uvmexp, &size, NULL, 0) >= 0 ? 1 : 0;
}
const char *
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_used(void)
{
long total, free, buffers, cached;
return (pscanf("/proc/meminfo",
"MemTotal: %ld kB\n"
"MemFree: %ld kB\n"
"MemAvailable: %ld kB\nBuffers: %ld kB\n"
"Cached: %ld kB\n",
&total, &free, &buffers, &buffers, &cached) == 5) ?
bprintf("%f", (float)(total - free - buffers - cached) /
1024 / 1024) :
NULL;
}
#elif defined(__OpenBSD__)
#include <sys/types.h>
#include <sys/sysctl.h>
#include <stdlib.h>
#include <unistd.h>
inline int
load_uvmexp(struct uvmexp *uvmexp)
{
int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
size_t size;
size = sizeof(*uvmexp);
const char * return sysctl(uvmexp_mib, 2, uvmexp, &size, NULL, 0) >= 0 ? 1 : 0;
ram_perc(void) }
{
struct uvmexp uvmexp;
int percent;
if (load_uvmexp(&uvmexp)) { const char *
percent = uvmexp.active * 100 / uvmexp.npages; ram_free(void)
return bprintf("%d", percent); {
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;
} }
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

260
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) {
fprintf(stderr, "fread '/proc/meminfo': %s\n", strerror(errno)); 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)
fclose(fp); return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL; if ((match = strstr(buf, "SwapFree")) == NULL)
sscanf(match, "SwapTotal: %ld kB\n", &total); return NULL;
sscanf(match, "SwapFree: %ld kB\n", &free);
if ((match = strstr(buf, "SwapFree")) == NULL)
return NULL; return bprintf("%f", (float)free / 1024 / 1024);
sscanf(match, "SwapFree: %ld kB\n", &free);
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)
fclose(fp); return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL; if ((match = strstr(buf, "SwapCached")) == NULL)
sscanf(match, "SwapTotal: %ld kB\n", &total); return NULL;
sscanf(match, "SwapCached: %ld kB\n", &cached);
if ((match = strstr(buf, "SwapCached")) == NULL)
return NULL; if ((match = strstr(buf, "SwapFree")) == NULL)
sscanf(match, "SwapCached: %ld kB\n", &cached); return NULL;
sscanf(match, "SwapFree: %ld kB\n", &free);
if ((match = strstr(buf, "SwapFree")) == NULL)
return NULL; return bprintf("%d", 100 * (total - free - cached) / total);
sscanf(match, "SwapFree: %ld kB\n", &free);
return bprintf("%d", 100 * (total - free - cached) / total);
}
const char *
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)); const char *
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);
return NULL;
}
fclose(fp); fclose(fp);
return NULL;
} if ((match = strstr(buf, "SwapTotal")) == NULL)
fclose(fp); return NULL;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapTotal")) == NULL)
return NULL; return bprintf("%f", (float)total / 1024 / 1024);
sscanf(match, "SwapTotal: %ld kB\n", &total);
return bprintf("%f", (float)total / 1024 / 1024);
}
const char *
swap_used(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)); const char *
swap_used(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;
}
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, "SwapCached")) == NULL) if ((match = strstr(buf, "SwapCached")) == NULL)
return NULL; return NULL;
sscanf(match, "SwapCached: %ld kB\n", &cached); sscanf(match, "SwapCached: %ld kB\n", &cached);
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)(total - free - cached) / 1024 / 1024); return bprintf("%f", (float)(total - free - cached) / 1024 / 1024);
} }
#elif defined(__OpenBSD__)
/* unimplemented */
#endif #endif

76
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>
const char *
temp(const char *null)
{
int mib[5];
size_t size;
struct sensor temp;
return bprintf("%d", (temp.value - 273150000) / 1000000); /* kelvin to celsius */ 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

101
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)
{ const char *
int h; uptime(void)
int m; {
int uptime = 0; int h;
struct sysinfo info; int m;
int uptime = 0;
sysinfo(&info); struct sysinfo info;
uptime = info.uptime;
sysinfo(&info);
h = uptime / 3600; uptime = info.uptime;
m = (uptime - h * 3600) / 60;
h = uptime / 3600;
return bprintf("%dh %dm", h, m); m = (uptime - h * 3600) / 60;
}
#elif defined(__OpenBSD__) return bprintf("%dh %dm", h, m);
const char *
uptime(void)
{
int h;
int m;
int uptime = 0;
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;
} }
#elif defined(__OpenBSD__)
#include <sys/sysctl.h>
#include <sys/time.h>
const char *
uptime(void)
{
int h;
int m;
int uptime = 0;
int mib[2];
size_t size;
time_t now;
struct timeval boottime;
time(&now);
h = uptime / 3600; mib[0] = CTL_KERN;
m = (uptime - h * 3600) / 60; mib[1] = KERN_BOOTTIME;
return bprintf("%dh %dm", h, m); 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

158
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"); fp = fopen("/proc/net/wireless", "r");
if (fp == NULL) { if (fp == NULL) {
fprintf(stderr, "fopen '/proc/net/wireless': %s\n", strerror(errno)); fprintf(stderr, "fopen '/proc/net/wireless': %s\n",
return NULL; strerror(errno));
} return NULL;
}
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
if (!(p = fgets(buf, sizeof(buf) - 1, fp))) if (!(p = fgets(buf, sizeof(buf) - 1, fp)))
break; break;
} }
fclose(fp); fclose(fp);
if (i < 2 || !p) if (i < 2 || !p)
return NULL; return NULL;
if ((datastart = strstr(buf, iface)) == NULL)
return NULL;
if ((datastart = strstr(buf, iface)) == NULL) datastart = (datastart+(strlen(iface)+1));
return NULL; sscanf(datastart + 1, " %*d %d %*d %*d\t\t %*d\t "
"%*d\t\t%*d\t\t %*d\t %*d\t\t %*d", &cur);
datastart = (datastart+(strlen(iface)+1)); perc = (float)cur / total * 100.0;
sscanf(datastart + 1, " %*d %d %*d %*d %*d %*d %*d %*d %*d %*d", &cur);
perc = (float)cur / total * 100.0; return bprintf("%.0f", perc);
}
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;
const char * memset(&wreq, 0, sizeof(struct iwreq));
wifi_essid(const char *iface) wreq.u.essid.length = IW_ESSID_MAX_SIZE+1;
{ snprintf(wreq.ifr_name, sizeof(wreq.ifr_name), "%s", 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)); if (sockfd == -1) {
wreq.u.essid.length = IW_ESSID_MAX_SIZE+1; fprintf(stderr, "socket 'AF_INET': %s\n",
snprintf(wreq.ifr_name, sizeof(wreq.ifr_name), "%s", iface); 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;
}
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;
}
close(sockfd); if (strcmp(id, "") == 0)
return NULL;
if (strcmp(id, "") == 0) else
return NULL; return id;
else }
return id; #elif defined(__OpenBSD__)
} /* unimplemented */
#endif #endif

Write Preview
Loading…
Cancel
Save