From e06a17c6b8fd8198a503dae861fe9c86effc0152 Mon Sep 17 00:00:00 2001
From: Nash Brooks <zombie@qtechofficial.com>
Date: Sat, 7 Aug 2021 01:31:57 -0400
Subject: [PATCH] added everything

---
 LICENSE                          |  40 +++++
 Makefile                         |  68 ++++++++
 README                           |  65 +++++++
 arg.h                            |  33 ++++
 components/battery.c             | 252 +++++++++++++++++++++++++++
 components/battery.o             | Bin 0 -> 5528 bytes
 components/cpu.c                 | 164 ++++++++++++++++++
 components/cpu.o                 | Bin 0 -> 3176 bytes
 components/datetime.c            |  19 +++
 components/datetime.o            | Bin 0 -> 1968 bytes
 components/disk.c                |  58 +++++++
 components/disk.o                | Bin 0 -> 3152 bytes
 components/entropy.c             |  27 +++
 components/entropy.o             | Bin 0 -> 1824 bytes
 components/hostname.c            |  16 ++
 components/hostname.o            | Bin 0 -> 1680 bytes
 components/ip.c                  |  60 +++++++
 components/ip.o                  | Bin 0 -> 2600 bytes
 components/kernel_release.c      |  18 ++
 components/kernel_release.o      | Bin 0 -> 1872 bytes
 components/keyboard_indicators.c |  48 ++++++
 components/keyboard_indicators.o | Bin 0 -> 2440 bytes
 components/keymap.c              |  87 ++++++++++
 components/keymap.o              | Bin 0 -> 4096 bytes
 components/load_avg.c            |  18 ++
 components/load_avg.o            | Bin 0 -> 1904 bytes
 components/netspeeds.c           | 139 +++++++++++++++
 components/netspeeds.o           | Bin 0 -> 2800 bytes
 components/num_files.c           |  31 ++++
 components/num_files.o           | Bin 0 -> 2192 bytes
 components/ram.c                 | 222 ++++++++++++++++++++++++
 components/ram.o                 | Bin 0 -> 3128 bytes
 components/run_command.c         |  30 ++++
 components/run_command.o         | Bin 0 -> 2176 bytes
 components/separator.c           |  10 ++
 components/separator.o           | Bin 0 -> 1200 bytes
 components/swap.c                | 284 +++++++++++++++++++++++++++++++
 components/swap.o                | Bin 0 -> 3968 bytes
 components/temperature.c         |  71 ++++++++
 components/temperature.o         | Bin 0 -> 1736 bytes
 components/uptime.c              |  33 ++++
 components/uptime.o              | Bin 0 -> 2008 bytes
 components/user.c                |  32 ++++
 components/user.o                | Bin 0 -> 2232 bytes
 components/volume.c              | 217 +++++++++++++++++++++++
 components/volume.o              | Bin 0 -> 3656 bytes
 components/wifi.c                | 272 +++++++++++++++++++++++++++++
 components/wifi.o                | Bin 0 -> 4336 bytes
 config.def.h                     |  73 ++++++++
 config.h                         |  73 ++++++++
 config.mk                        |  22 +++
 slstatus                         | Bin 0 -> 31824 bytes
 slstatus.1                       |  28 +++
 slstatus.c                       | 141 +++++++++++++++
 slstatus.h                       |  84 +++++++++
 slstatus.o                       | Bin 0 -> 6184 bytes
 util.c                           | 146 ++++++++++++++++
 util.h                           |  16 ++
 util.o                           | Bin 0 -> 5976 bytes
 59 files changed, 2897 insertions(+)
 create mode 100644 LICENSE
 create mode 100644 Makefile
 create mode 100644 README
 create mode 100644 arg.h
 create mode 100644 components/battery.c
 create mode 100644 components/battery.o
 create mode 100644 components/cpu.c
 create mode 100644 components/cpu.o
 create mode 100644 components/datetime.c
 create mode 100644 components/datetime.o
 create mode 100644 components/disk.c
 create mode 100644 components/disk.o
 create mode 100644 components/entropy.c
 create mode 100644 components/entropy.o
 create mode 100644 components/hostname.c
 create mode 100644 components/hostname.o
 create mode 100644 components/ip.c
 create mode 100644 components/ip.o
 create mode 100644 components/kernel_release.c
 create mode 100644 components/kernel_release.o
 create mode 100644 components/keyboard_indicators.c
 create mode 100644 components/keyboard_indicators.o
 create mode 100644 components/keymap.c
 create mode 100644 components/keymap.o
 create mode 100644 components/load_avg.c
 create mode 100644 components/load_avg.o
 create mode 100644 components/netspeeds.c
 create mode 100644 components/netspeeds.o
 create mode 100644 components/num_files.c
 create mode 100644 components/num_files.o
 create mode 100644 components/ram.c
 create mode 100644 components/ram.o
 create mode 100644 components/run_command.c
 create mode 100644 components/run_command.o
 create mode 100644 components/separator.c
 create mode 100644 components/separator.o
 create mode 100644 components/swap.c
 create mode 100644 components/swap.o
 create mode 100644 components/temperature.c
 create mode 100644 components/temperature.o
 create mode 100644 components/uptime.c
 create mode 100644 components/uptime.o
 create mode 100644 components/user.c
 create mode 100644 components/user.o
 create mode 100644 components/volume.c
 create mode 100644 components/volume.o
 create mode 100644 components/wifi.c
 create mode 100644 components/wifi.o
 create mode 100644 config.def.h
 create mode 100644 config.h
 create mode 100644 config.mk
 create mode 100755 slstatus
 create mode 100644 slstatus.1
 create mode 100644 slstatus.c
 create mode 100644 slstatus.h
 create mode 100644 slstatus.o
 create mode 100644 util.c
 create mode 100644 util.h
 create mode 100644 util.o

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..b88a9cb
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,40 @@
+ISC License
+
+Copyright 2016-2020 Aaron Marcher <me@drkhsh.at>
+
+Copyright 2016 Roy Freytag <rfreytag@hs-mittweida.de>
+Copyright 2016 Vincent Loupmon <vincentloupmon@gmail.com>
+Copyright 2016 Daniel Walter <d.walter@0x90.at>
+Copyright 2016-2018 Ali H. Fardan <raiz@firemail.cc>
+Copyright 2016 Jody Leonard <me@jodyleonard.com>
+Copyright 2016-2018 Quentin Rameau <quinq@fifth.space>
+Copyright 2016 Mike Coddington <mike@coddington.us>
+Copyright 2016-2018 parazyd <parazyd@dyne.org>
+Copyright 2017 Tobias Stoeckmann <tobias@stoeckmann.org>
+Copyright 2017-2018 Laslo Hunhold <dev@frign.de>
+Copyright 2018 Darron Anderson <darronanderson@protonmail.com>
+Copyright 2018 Josuah Demangeon <mail@josuah.net>
+Copyright 2018 Tobias Tschinkowitz <tobias@he4d.net>
+Copyright 2018 David Demelier <markand@malikania.fr>
+Copyright 2018-2019 Michael Buch <michaelbuch12@gmail.com>
+Copyright 2018 Ian Remmler <ian@remmler.org>
+Copyright 2016-2019 Joerg Jung <jung@openbsd.org>
+Copyright 2019 Ryan Kes <alrayyes@gmail.com>
+Copyright 2019 Cem Keylan <cem@ckyln.com>
+Copyright 2019 dsp <dsp@2f30.org>
+Copyright 2019-2020 Ingo Feinerer <feinerer@logic.at>
+Copyright 2020 Alexandre Ratchov <alex@caoua.org>
+Copyright 2020 Mart Lubbers <mart@martlubbers.net>
+Copyright 2020 Daniel Moch <daniel@danielmoch.com>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..2f93b87
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,68 @@
+# See LICENSE file for copyright and license details
+# slstatus - suckless status monitor
+.POSIX:
+
+include config.mk
+
+REQ = util
+COM =\
+	components/battery\
+	components/cpu\
+	components/datetime\
+	components/disk\
+	components/entropy\
+	components/hostname\
+	components/ip\
+	components/kernel_release\
+	components/keyboard_indicators\
+	components/keymap\
+	components/load_avg\
+	components/netspeeds\
+	components/num_files\
+	components/ram\
+	components/run_command\
+	components/separator\
+	components/swap\
+	components/temperature\
+	components/uptime\
+	components/user\
+	components/volume\
+	components/wifi
+
+all: slstatus
+
+$(COM:=.o): config.mk $(REQ:=.h)
+slstatus.o: slstatus.c slstatus.h arg.h config.h config.mk $(REQ:=.h)
+
+.c.o:
+	$(CC) -o $@ -c $(CPPFLAGS) $(CFLAGS) $<
+
+config.h:
+	cp config.def.h $@
+
+slstatus: slstatus.o $(COM:=.o) $(REQ:=.o)
+	$(CC) -o $@ $(LDFLAGS) $(COM:=.o) $(REQ:=.o) slstatus.o $(LDLIBS)
+
+clean:
+	rm -f slstatus slstatus.o $(COM:=.o) $(REQ:=.o)
+
+dist:
+	rm -rf "slstatus-$(VERSION)"
+	mkdir -p "slstatus-$(VERSION)/components"
+	cp -R LICENSE Makefile README config.mk config.def.h \
+	      arg.h slstatus.c $(COM:=.c) $(REQ:=.c) $(REQ:=.h) \
+	      slstatus.1 "slstatus-$(VERSION)"
+	tar -cf - "slstatus-$(VERSION)" | gzip -c > "slstatus-$(VERSION).tar.gz"
+	rm -rf "slstatus-$(VERSION)"
+
+install: all
+	mkdir -p "$(DESTDIR)$(PREFIX)/bin"
+	cp -f slstatus "$(DESTDIR)$(PREFIX)/bin"
+	chmod 755 "$(DESTDIR)$(PREFIX)/bin/slstatus"
+	mkdir -p "$(DESTDIR)$(MANPREFIX)/man1"
+	cp -f slstatus.1 "$(DESTDIR)$(MANPREFIX)/man1"
+	chmod 644 "$(DESTDIR)$(MANPREFIX)/man1/slstatus.1"
+
+uninstall:
+	rm -f "$(DESTDIR)$(PREFIX)/bin/slstatus"
+	rm -f "$(DESTDIR)$(MANPREFIX)/man1/slstatus.1"
diff --git a/README b/README
new file mode 100644
index 0000000..86fe988
--- /dev/null
+++ b/README
@@ -0,0 +1,65 @@
+slstatus - suckless status
+==========================
+slstatus is a suckless status monitor for window managers that use WM_NAME
+(e.g. dwm) or stdin to fill the status bar.
+
+
+Features
+--------
+- Battery percentage/state/time left
+- CPU usage
+- CPU frequency
+- Custom shell commands
+- Date and time
+- Disk status (free storage, percentage, total storage and used storage)
+- Available entropy
+- Username/GID/UID
+- Hostname
+- IP address (IPv4 and IPv6)
+- Kernel version
+- Keyboard indicators
+- Keymap
+- Load average
+- Network speeds (RX and TX)
+- Number of files in a directory (hint: Maildir)
+- Memory status (free memory, percentage, total memory and used memory)
+- Swap status (free swap, percentage, total swap and used swap)
+- Temperature
+- Uptime
+- Volume percentage
+- WiFi signal percentage and ESSID
+
+
+Requirements
+------------
+Currently slstatus works on FreeBSD, Linux and OpenBSD.
+In order to build slstatus you need the Xlib header files.
+
+
+Installation
+------------
+Edit config.mk to match your local setup (slstatus is installed into the
+/usr/local namespace by default).
+
+Afterwards enter the following command to build and install slstatus (if
+necessary as root):
+
+    make clean install
+
+
+Running slstatus
+----------------
+See the man page for details.
+
+
+Configuration
+-------------
+slstatus can be customized by creating a custom config.h and (re)compiling the
+source code. This keeps it fast, secure and simple.
+
+
+Upcoming
+--------
+
+A release (v1.0) will come soon... ;)
+After a long phase of inactivity, development has been continued!
diff --git a/arg.h b/arg.h
new file mode 100644
index 0000000..e0adb9f
--- /dev/null
+++ b/arg.h
@@ -0,0 +1,33 @@
+/* See LICENSE file for copyright and license details. */
+#ifndef ARG_H
+#define ARG_H
+
+extern char *argv0;
+
+/* int main(int argc, char *argv[]) */
+#define ARGBEGIN for (argv0 = *argv, *argv ? (argc--, argv++) : ((void *)0);      \
+                      *argv && (*argv)[0] == '-' && (*argv)[1]; argc--, argv++) { \
+                 	int i_, argused_;                                         \
+                 	if ((*argv)[1] == '-' && !(*argv)[2]) {                   \
+                 		argc--, argv++;                                   \
+                 		break;                                            \
+                 	}                                                         \
+                 	for (i_ = 1, argused_ = 0; (*argv)[i_]; i_++) {           \
+                 		switch((*argv)[i_])
+#define ARGEND   		if (argused_) {                                   \
+                 			if ((*argv)[i_ + 1]) {                    \
+                 				break;                            \
+                 			} else {                                  \
+                 				argc--, argv++;                   \
+                 				break;                            \
+                 			}                                         \
+                 		}                                                 \
+                 	}                                                         \
+                 }
+#define ARGC()   ((*argv)[i_])
+#define ARGF_(x) (((*argv)[i_ + 1]) ? (argused_ = 1, &((*argv)[i_ + 1])) :        \
+                  (*(argv + 1))     ? (argused_ = 1, *(argv + 1))        : (x))
+#define EARGF(x) ARGF_(((x), exit(1), (char *)0))
+#define ARGF()   ARGF_((char *)0)
+
+#endif
diff --git a/components/battery.c b/components/battery.c
new file mode 100644
index 0000000..f2b0f14
--- /dev/null
+++ b/components/battery.c
@@ -0,0 +1,252 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <string.h>
+
+#include "../util.h"
+
+#if defined(__linux__)
+	#include <limits.h>
+	#include <stdint.h>
+	#include <unistd.h>
+
+	static const char *
+	pick(const char *bat, const char *f1, const char *f2, char *path,
+	     size_t length)
+	{
+		if (esnprintf(path, length, f1, bat) > 0 &&
+		    access(path, R_OK) == 0) {
+			return f1;
+		}
+
+		if (esnprintf(path, length, f2, bat) > 0 &&
+		    access(path, R_OK) == 0) {
+			return f2;
+		}
+
+		return NULL;
+	}
+
+	const char *
+	battery_perc(const char *bat)
+	{
+		int perc;
+		char path[PATH_MAX];
+
+		if (esnprintf(path, sizeof(path),
+		              "/sys/class/power_supply/%s/capacity", bat) < 0) {
+			return NULL;
+		}
+		if (pscanf(path, "%d", &perc) != 1) {
+			return NULL;
+		}
+
+		return bprintf("%d", perc);
+	}
+
+	const char *
+	battery_state(const char *bat)
+	{
+		static struct {
+			char *state;
+			char *symbol;
+		} map[] = {
+			{ "Charging",    "+" },
+			{ "Discharging", "-" },
+			{ "Full",        "o" },
+		};
+		size_t i;
+		char path[PATH_MAX], state[12];
+
+		if (esnprintf(path, sizeof(path),
+		              "/sys/class/power_supply/%s/status", bat) < 0) {
+			return NULL;
+		}
+		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;
+	}
+
+	const char *
+	battery_remaining(const char *bat)
+	{
+		uintmax_t charge_now, current_now, m, h;
+		double timeleft;
+		char path[PATH_MAX], state[12];
+
+		if (esnprintf(path, sizeof(path),
+		              "/sys/class/power_supply/%s/status", bat) < 0) {
+			return NULL;
+		}
+		if (pscanf(path, "%12s", state) != 1) {
+			return NULL;
+		}
+
+		if (!pick(bat, "/sys/class/power_supply/%s/charge_now",
+		          "/sys/class/power_supply/%s/energy_now", path,
+		          sizeof(path)) ||
+		    pscanf(path, "%ju", &charge_now) < 0) {
+			return NULL;
+		}
+
+		if (!strcmp(state, "Discharging")) {
+			if (!pick(bat, "/sys/class/power_supply/%s/current_now",
+			          "/sys/class/power_supply/%s/power_now", path,
+			          sizeof(path)) ||
+			    pscanf(path, "%ju", &current_now) < 0) {
+				return NULL;
+			}
+
+			if (current_now == 0) {
+				return NULL;
+			}
+
+			timeleft = (double)charge_now / (double)current_now;
+			h = timeleft;
+			m = (timeleft - (double)h) * 60;
+
+			return bprintf("%juh %jum", h, m);
+		}
+
+		return "";
+	}
+#elif defined(__OpenBSD__)
+	#include <fcntl.h>
+	#include <machine/apmvar.h>
+	#include <sys/ioctl.h>
+	#include <unistd.h>
+
+	static int
+	load_apm_power_info(struct apm_power_info *apm_info)
+	{
+		int fd;
+
+		fd = open("/dev/apm", O_RDONLY);
+		if (fd < 0) {
+			warn("open '/dev/apm':");
+			return 0;
+		}
+
+		memset(apm_info, 0, sizeof(struct apm_power_info));
+		if (ioctl(fd, APM_IOC_GETPOWER, apm_info) < 0) {
+			warn("ioctl 'APM_IOC_GETPOWER':");
+			close(fd);
+			return 0;
+		}
+		return close(fd), 1;
+	}
+
+	const char *
+	battery_perc(const char *unused)
+	{
+		struct apm_power_info apm_info;
+
+		if (load_apm_power_info(&apm_info)) {
+			return bprintf("%d", apm_info.battery_life);
+		}
+
+		return NULL;
+	}
+
+	const char *
+	battery_state(const char *unused)
+	{
+		struct {
+			unsigned int state;
+			char *symbol;
+		} map[] = {
+			{ APM_AC_ON,      "+" },
+			{ APM_AC_OFF,     "-" },
+		};
+		struct apm_power_info apm_info;
+		size_t i;
+
+		if (load_apm_power_info(&apm_info)) {
+			for (i = 0; i < LEN(map); i++) {
+				if (map[i].state == apm_info.ac_state) {
+					break;
+				}
+			}
+			return (i == LEN(map)) ? "?" : map[i].symbol;
+		}
+
+		return NULL;
+	}
+
+	const char *
+	battery_remaining(const char *unused)
+	{
+		struct apm_power_info apm_info;
+
+		if (load_apm_power_info(&apm_info)) {
+			if (apm_info.ac_state != APM_AC_ON) {
+				return bprintf("%uh %02um",
+			                       apm_info.minutes_left / 60,
+				               apm_info.minutes_left % 60);
+			} else {
+				return "";
+			}
+		}
+
+		return NULL;
+	}
+#elif defined(__FreeBSD__)
+	#include <sys/sysctl.h>
+
+	const char *
+	battery_perc(const char *unused)
+	{
+		int cap;
+		size_t len;
+
+		len = sizeof(cap);
+		if (sysctlbyname("hw.acpi.battery.life", &cap, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		return bprintf("%d", cap);
+	}
+
+	const char *
+	battery_state(const char *unused)
+	{
+		int state;
+		size_t len;
+
+		len = sizeof(state);
+		if (sysctlbyname("hw.acpi.battery.state", &state, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		switch(state) {
+			case 0:
+			case 2:
+				return "+";
+			case 1:
+				return "-";
+			default:
+				return "?";
+		}
+	}
+
+	const char *
+	battery_remaining(const char *unused)
+	{
+		int rem;
+		size_t len;
+
+		len = sizeof(rem);
+		if (sysctlbyname("hw.acpi.battery.time", &rem, &len, NULL, 0) == -1
+				|| !len
+				|| rem == -1)
+			return NULL;
+
+		return bprintf("%uh %02um", rem / 60, rem % 60);
+	}
+#endif
diff --git a/components/battery.o b/components/battery.o
new file mode 100644
index 0000000000000000000000000000000000000000..f49e64d92dba41a2fb84a18e490c890959d4fd59
GIT binary patch
literal 5528
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

literal 0
HcmV?d00001

diff --git a/components/cpu.c b/components/cpu.c
new file mode 100644
index 0000000..9e28003
--- /dev/null
+++ b/components/cpu.c
@@ -0,0 +1,164 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../util.h"
+
+#if defined(__linux__)
+	const char *
+	cpu_freq(void)
+	{
+		uintmax_t freq;
+
+		/* in kHz */
+		if (pscanf("/sys/devices/system/cpu/cpu0/cpufreq/"
+		           "scaling_cur_freq", "%ju", &freq) != 1) {
+			return NULL;
+		}
+
+		return fmt_human(freq * 1000, 1000);
+	}
+
+	const char *
+	cpu_perc(void)
+	{
+		static long double a[7];
+		long double b[7], sum;
+
+		memcpy(b, a, sizeof(b));
+		/* cpu user nice system idle iowait irq softirq */
+		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 (b[0] == 0) {
+			return NULL;
+		}
+
+		sum = (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]);
+
+		if (sum == 0) {
+			return NULL;
+		}
+
+		return bprintf("%d", (int)(100 *
+		               ((b[0] + b[1] + b[2] + b[5] + b[6]) -
+		                (a[0] + a[1] + a[2] + a[5] + a[6])) / sum));
+	}
+#elif defined(__OpenBSD__)
+	#include <sys/param.h>
+	#include <sys/sched.h>
+	#include <sys/sysctl.h>
+
+	const char *
+	cpu_freq(void)
+	{
+		int freq, mib[2];
+		size_t size;
+
+		mib[0] = CTL_HW;
+		mib[1] = HW_CPUSPEED;
+
+		size = sizeof(freq);
+
+		/* in MHz */
+		if (sysctl(mib, 2, &freq, &size, NULL, 0) < 0) {
+			warn("sysctl 'HW_CPUSPEED':");
+			return NULL;
+		}
+
+		return fmt_human(freq * 1E6, 1000);
+	}
+
+	const char *
+	cpu_perc(void)
+	{
+		int mib[2];
+		static uintmax_t a[CPUSTATES];
+		uintmax_t b[CPUSTATES], sum;
+		size_t size;
+
+		mib[0] = CTL_KERN;
+		mib[1] = KERN_CPTIME;
+
+		size = sizeof(a);
+
+		memcpy(b, a, sizeof(b));
+		if (sysctl(mib, 2, &a, &size, NULL, 0) < 0) {
+			warn("sysctl 'KERN_CPTIME':");
+			return NULL;
+		}
+		if (b[0] == 0) {
+			return NULL;
+		}
+
+		sum = (a[CP_USER] + a[CP_NICE] + a[CP_SYS] + a[CP_INTR] + a[CP_IDLE]) -
+		      (b[CP_USER] + b[CP_NICE] + b[CP_SYS] + b[CP_INTR] + b[CP_IDLE]);
+
+		if (sum == 0) {
+			return NULL;
+		}
+
+		return bprintf("%d", 100 *
+		               ((a[CP_USER] + a[CP_NICE] + a[CP_SYS] +
+		                 a[CP_INTR]) -
+		                (b[CP_USER] + b[CP_NICE] + b[CP_SYS] +
+		                 b[CP_INTR])) / sum);
+	}
+#elif defined(__FreeBSD__)
+	#include <sys/param.h>
+	#include <sys/sysctl.h>
+	#include <devstat.h>
+
+	const char *
+	cpu_freq(void)
+	{
+		int freq;
+		size_t size;
+
+		size = sizeof(freq);
+		/* in MHz */
+		if (sysctlbyname("hw.clockrate", &freq, &size, NULL, 0) == -1
+				|| !size) {
+			warn("sysctlbyname 'hw.clockrate':");
+			return NULL;
+		}
+
+		return fmt_human(freq * 1E6, 1000);
+	}
+
+	const char *
+	cpu_perc(void)
+	{
+		size_t size;
+		static long a[CPUSTATES];
+		long b[CPUSTATES], sum;
+
+		size = sizeof(a);
+		memcpy(b, a, sizeof(b));
+		if (sysctlbyname("kern.cp_time", &a, &size, NULL, 0) == -1
+				|| !size) {
+			warn("sysctlbyname 'kern.cp_time':");
+			return NULL;
+		}
+		if (b[0] == 0) {
+			return NULL;
+		}
+
+		sum = (a[CP_USER] + a[CP_NICE] + a[CP_SYS] + a[CP_INTR] + a[CP_IDLE]) -
+		      (b[CP_USER] + b[CP_NICE] + b[CP_SYS] + b[CP_INTR] + b[CP_IDLE]);
+
+		if (sum == 0) {
+			return NULL;
+		}
+
+		return bprintf("%d", 100 *
+		               ((a[CP_USER] + a[CP_NICE] + a[CP_SYS] +
+		                 a[CP_INTR]) -
+		                (b[CP_USER] + b[CP_NICE] + b[CP_SYS] +
+		                 b[CP_INTR])) / sum);
+	}
+#endif
diff --git a/components/cpu.o b/components/cpu.o
new file mode 100644
index 0000000000000000000000000000000000000000..19773cb91dad28fff114dfc8af53ee73953eacc6
GIT binary patch
literal 3176
zcma);O>7%Q6o6-)gqSwiCIl(aO7&q4DYWajB&ezaa(<lb!H@_76ew~wj$Nm<9phc2
zrbHo8sMHWy%7FtC5<=pVLl1>BYMq}$K^y>aaAaaZC8R{Hs`SPIDZDp3&)H04sV~}j
z?|t*$%<S{bY(9%b2VIK7NEG%u+xLhvw&LEm!`uurFY_>c;eNYb>_(y&UqdyaFEs`_
z&|e%--Jz1ccy}9l?_#NU?@pmjpX^b$8yLHV4ez<<f~ciY)jgrV+{RO_Cf=bhY_zZI
z^Y@o=v|<yEBIc@`wjDlWWkyZe0Ic&hORrgHYgR|iYOh)D5q)9XCz_)Et6m%_MT`1w
zv>5&?RHB9Wzh|2dDrt4Bvg7@F%^Ugc^WVMKR$&zj|2BKC-2wwTN2;sPhN0!_vs>~=
zi@vnlS>AwXKhN>~xmr1;R@XLvf_L!QA<)f-sjimS%WDwotNvYiuvNY4vfkUAQD>_g
zqU6b?0d*GA=YDBPLeXbJrRv7!&(&4<+bKVVm8w46Osg}M<0`1xr7l&U-?$EV2m7|l
zTjhJLylugj{@_Qkqt-F1jsz|hSkRm{gA<8QCgTYcZ7Y!p#&ZRHI<ZOS6CVf7xRIXB
zUW~;H`4|Egc**n!qRDy>3+D1u@t|oL77I+k?05RuP=Eh9f5*_9@0|39LRv`cWULW-
z{P5uBfDYzjN(mY5VMX|`*SNF^tz3PJDOY^Tv6g1{G6W+(F8an%4|x2pk38;EV0H<<
zfP)TszEWHlJl`r2&k8&@l@C43itCRf9(UxZ;c<)5M--+uvWI(*bO30mt@dDV1An`N
ztQlOz!E>VfDA)Xm97ym9jx}-0v)pN7=bRAi=LP>j;wJ=8NL=Oq6B1?YB#>6ed-0kA
zI|Glsrh_SZ9X?!#zh8%60*>?2eEc^9X4Z*kus^jpGhi=i(SF{9&^m+7E7-h>O*h8b
z`!+Td9q#Lm#)bz6-;RvNMtl3Bkr>Ot{>~;@GGoP3g^ZD9u^4RK_~lqUbvc$aCewU?
zTp}N5<GK7~)=I*HK=AiOalwPX-hX?xco2dh$LbP)0U-$fo_Ml}hrvccj=99KPAJH|
z@DNWU1i|s~Y+OJG1nY!?9M?wi(+EK*p7<Q6Hpk6R{0j%i@mqxdrNrsXeIs!^cPJ~i
zs?FOY{2wG975<MBr}w%mxLmjA#6=;$*9nQ!`d^edtv@JnT2HscX+7s9PVYM=@gA}6
zc?W+I7}fbZ2S4KAw*|-decHkOV58vs;zM#)7{te^Lo=r{mNCvW)5_aAMOHqMHZ&`7
z#bVloVHr#tH%+GHr_jN0xT0%r+_buw7N5#w5?P4PPFV>J?(5V1kO==`wxGeK4~N8>
zhD01ak%B{KWaL|i7Weqt5208R`KAg3L-|M4%l7uaALJhc18W&3AoQHLa&w}XxKD5>
z`Vh2>I6Sw=={qDa3y3`ONlVLNxIb`AIX^7&={rFAelmm(fyOcM{&foFr<@RMnxAx7
zuvRH<Ma+-2aSHjQ-+)dWtJ4_-_6?E$jKpbP((gh)+0M}0k6FJYB;kD~hnED9*G0b{
z%{2=K&M)Wh3NS{2Ld*Ghe;&4fcEtyP=Ewbm=a}+o{~R_qPBkJn#7$8g{3hW40&+gy
h8S>r%WPfx(eafBvMy@s9A&2Gr#YETlQ@JJQ{|_I>&x8N~

literal 0
HcmV?d00001

diff --git a/components/datetime.c b/components/datetime.c
new file mode 100644
index 0000000..c3efae3
--- /dev/null
+++ b/components/datetime.c
@@ -0,0 +1,19 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <time.h>
+
+#include "../util.h"
+
+const char *
+datetime(const char *fmt)
+{
+	time_t t;
+
+	t = time(NULL);
+	if (!strftime(buf, sizeof(buf), fmt, localtime(&t))) {
+		warn("strftime: Result string exceeds buffer size");
+		return NULL;
+	}
+
+	return buf;
+}
diff --git a/components/datetime.o b/components/datetime.o
new file mode 100644
index 0000000000000000000000000000000000000000..2f168a5239b5e6c994333572be8953073d69ca57
GIT binary patch
literal 1968
zcmb_c&1(};5T8v`8?}b06@pdSLzIfTWW`g#k`J3~akWq*B371dvS~u|QFk}k)<X})
z!%_=9`X_kwFVKko5#9tZ3VP6cvCeGXq}y$B5q~gwGr#$GZ)e`i=B!?bND?q4n1KU}
zS%7r(K+pJU2I6oEvZXn1Pu+i@?OY^Q+xnTTXxq`tQ)GB|QZcpr-FJB3G%uR+b=~{=
z4zQl)ebKxRJ~iicHShDim)%Z6?P@!>DaCi7wOvZZD%!OPzot9dE4TG2`6Rpe(Q)mn
zTW?y^@`B}b8m^2)y|pY`Yh}x-IPy}bTD5H1sc%>S#e9BRo+{pdcvV(aMOD(c34NA~
zGKzv8h=9}$d@A;$XLC;`FpeN?EP%9@kS52+V!P-}A$P&|0Bq8lizi-13i0ID$lZ84
zQi~_E@kA~j6Cp<ysvm{l`$rr|j0~8_xF1NTK8(|7o(aVJXF={fO5$*+Z(SO~pBuv8
z8p6*E;fq6feFzT~)3s=#N*NSApYGd$qXeU<&*!qbF<&S=m@OHlY)+pwpwTXy4axz&
z4)ENxTVNQDYnE4xa&5(^n)L>52`A|X5kaBu?d|tK^CQsg$55E3J3=6yhR1xKNCff6
zQJ8;3B!cRXpfJBkB!c2kpfK+ci6EZN#=ML=f$EU-p*ZVJ*IWVxzqPm4ShKB$skqjf
z3kr781ZBx_K(X6oP&nRsP|EFQ(`sQztL<6}Uilk-lZ3t8>L{yrd)2btbxfs#R?Vo|
zCN}rKK*lO`*N=s&WrWT5mEHXA*q%g%dX-^9tiME)-Uyp|NxA&sl7hb?c$!TR?}J7_
z5AS~+eN^*b^Ht2Hnm18`;Qgt75WGLH8FZ4)_mX3O2<0pjV&yzu=a6ST82Tq@1oUw1
zWAxGcICLi|UId2E#r>xc!ZQ>K4d<steg=I(g!AbU51RjLF%X_J&7a;S=QBTOZ`yBF
r>@SOT968!2oKH2wvquVc#RoklBLGpZ&(Qz#p!~Oje9@2WDdGITC->W{

literal 0
HcmV?d00001

diff --git a/components/disk.c b/components/disk.c
new file mode 100644
index 0000000..15a221b
--- /dev/null
+++ b/components/disk.c
@@ -0,0 +1,58 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <sys/statvfs.h>
+
+#include "../util.h"
+
+const char *
+disk_free(const char *path)
+{
+	struct statvfs fs;
+
+	if (statvfs(path, &fs) < 0) {
+		warn("statvfs '%s':", path);
+		return NULL;
+	}
+
+	return fmt_human(fs.f_frsize * fs.f_bavail, 1024);
+}
+
+const char *
+disk_perc(const char *path)
+{
+	struct statvfs fs;
+
+	if (statvfs(path, &fs) < 0) {
+		warn("statvfs '%s':", path);
+		return NULL;
+	}
+
+	return bprintf("%d", (int)(100 *
+	               (1.0f - ((float)fs.f_bavail / (float)fs.f_blocks))));
+}
+
+const char *
+disk_total(const char *path)
+{
+	struct statvfs fs;
+
+	if (statvfs(path, &fs) < 0) {
+		warn("statvfs '%s':", path);
+		return NULL;
+	}
+
+	return fmt_human(fs.f_frsize * fs.f_blocks, 1024);
+}
+
+const char *
+disk_used(const char *path)
+{
+	struct statvfs fs;
+
+	if (statvfs(path, &fs) < 0) {
+		warn("statvfs '%s':", path);
+		return NULL;
+	}
+
+	return fmt_human(fs.f_frsize * (fs.f_blocks - fs.f_bfree), 1024);
+}
diff --git a/components/disk.o b/components/disk.o
new file mode 100644
index 0000000000000000000000000000000000000000..7bf88cb9b84ec56c020b0510a6c9ceabde03e38c
GIT binary patch
literal 3152
zcmcIl&2Jk;6o2a`jSIzVLMtqa&>kFWXuGOgB&3QD=X;S1mD&Uq30OAv8i&MoWN(6l
zB5D*B)iRZGgbN2wy}@6AOv)i34shVk5dlI}z9CR~zuB31vWWpj>XY8=%<p~9n>Vx9
zr}Hy0!yrWly+HkyLW#EG{drDIb7WG2=AHK6&gR#xqSF}~%do&{Po<mLu5&9$$A5<6
zjqdtMUblaDZat5+0JGg+Pdc5AbkZ?D-$-Y^q#-GAI&<k}(K&NMI17e_wzK(L>y0~y
z54GlWrqUVbMz=ZAbIhj^yS=^nli~dEi*sxn(00$f)`eDTS8Hd#*0-$nP0xJutDc#B
z2z!xR%65C^>pMO3H39a_vv<R^@5f%WvZd~G*&f3QrJOSxX-h;BXO;Y~tu+EKSSvNG
z(_@X(muRerI<;OT+L@r)$;nGrX7-i&r>tz&&f4b*=S~*$Ff$7%Mn)Hy>On)Uk1+;1
z5q`*c?+O{sq;cx_NPLTxEyf?0vL$@S6Uh%_vxzMu<|UHji8w<RbB-DG9frQnwyq;m
zX7RuIxe0rw6%2hpCFKY3L4<t`(cOCo$&T#qx-UiEVRiZ#W}?&R=w6UlqXHS`o4J=B
z70aWd-ns-e8`a{9Ju~(sb5d87^XCTOQv>jq2H;l*;HW+FQF(}SVyrqqe@*H?i^4J~
zyAOB{Kc7iloD&p^i;X3_Kz4reJccZWix@5lkz1<!KDo2`%M;^y_wvll)#*8RZhRs?
z?UL+lde^I0sZ<Hv@@mDalIyadu;doXOK!<qTn_!L`1JxUtkf5)K`BInTHs0HYQvXJ
z_5^Zb8e&F||8*}U8z57R`3SSZF9KwO{sYVk&jVxv{vfl$J%CKWk25R04Uj1s_mdFb
z7xz<%N8|pf=|iUct6vK8$K6)ADbE8qx>w;TiNgnaSK;S0T+e@A!}YrPnt#1+?`ZmZ
z-8MB`uiM8OuE*_axE}X=iAT@tM@?Uk+tYA8ZX6DnPzOD(1&|41sUp@>V(jCp|H~0v
z-H(qVxVj%?H`XhGx4_?^9)8PeR`-`ZJMfzU*+nn#$X;kP$gbD0fI2_ryURi&c!umk
zty1x;tY57KzRmCYIdMhg`t9nfy;8674GGrS5Z?VVUp%kk%j^#SvDg%)jlPUI#z3Qb
z@pvtdLC7$iVn*$A%sREu#7r4!kF$Yo_&yV*AY{V32^_tr)0IeEC5y&C%L4d3tbLYk
z;qwBsPAdMxI>>VsUwv~D3;!d1<)X}A?N>=qE0FrW%yanSU;7?fmiCYALHEahmE|fI
zUG@6^tY3+ZMwp}OEeS;Pitguq89!?Og#>QvN%1^tzs}e}{c{^hF})?m@NVNhQ1+^S
xu=i+em|T+$q249@|KT!fk2fjWI}Fhu@_;&6XcVnA`r{z`xD0etv&A%O{|`rd0<r)A

literal 0
HcmV?d00001

diff --git a/components/entropy.c b/components/entropy.c
new file mode 100644
index 0000000..2a485de
--- /dev/null
+++ b/components/entropy.c
@@ -0,0 +1,27 @@
+/* See LICENSE file for copyright and license details. */
+#if defined(__linux__)
+	#include <stdint.h>
+	#include <stdio.h>
+
+	#include "../util.h"
+
+	const char *
+	entropy(void)
+	{
+		uintmax_t num;
+
+		if (pscanf("/proc/sys/kernel/random/entropy_avail", "%ju", &num)
+		    != 1) {
+			return NULL;
+		}
+
+		return bprintf("%ju", num);
+	}
+#elif defined(__OpenBSD__) | defined(__FreeBSD__)
+	const char *
+	entropy(void)
+	{
+		/* Unicode Character 'INFINITY' (U+221E) */
+		return "\xe2\x88\x9e";
+	}
+#endif
diff --git a/components/entropy.o b/components/entropy.o
new file mode 100644
index 0000000000000000000000000000000000000000..6c1447987e0cf30f1b9f99817c777ac7e01ca710
GIT binary patch
literal 1824
zcmbtU&1(};5T8vO8!?7eD+pECLn`&7FJ1Le3QE$LW`$tEHU|%~Y&IKP+ic?QRvJBc
zC<q}G`XA_@63~PG4<5vm2l3-B)S2Bk>2^skIxzcYe)IL-o7wleQd>zW3NR^f4~{fO
z0p3j<$;D7CLJrPC-PoTe)!4rqF8v?I-gmWW3?^si2=3p{XY`@b|N4#0rT$PKmJUDe
zWR1a{ywU#|qQ+o7pJ^I5ro)gR9f5lv)F<y}pY1@Q>vimc-}4Jwj^{et1<!Juop!--
z1FzHVnbr$ya~q&qE-z_w)ra+Knyw37EKot1MAneg$Y_HUC_}=S6shx>r=>x8`3RI<
zRhh|7We(7I8F6AFlRl-K`X*J+X{l;XE#)!<jU&oC3BM1=*(S!^^qJ6+c6*%EP)&#D
ziCZqBaz2(P+#6z7kfWHmH^A)^@TC**<r8p_w=ZlEwekXebjHA})>fBGHFI@kWv#Mq
zu9uc;6%)F?ZMiLIbiGYCXn|?^fn{%*_Qsak3Oh(U<=&)Frjh$|7*TXDfc=Yn7{87>
z5yed*GhRfQh;V8S<8=a&2tSR?xP~$j<tHAI@O$mRYJl(qFIqQP@|<l;1kP>%qG<&d
zh=%Wj@H(WBJ5C`8yVGvtU4d{rfg^AP=fh)5{i(YnaJ;*Y7xXZc5;_}Z%d^_fXb1l#
zXc$d1cq);lD0Q9}HuHbL`V0zmS49TodLS=pSL)Osisc{SlEkk{JobEqmbcQLT$1%~
zq66jp*LWRcDd#QZIB|WRAGUFQUW;fTIeJal3*eI!FC0Ok#BsbnK$PXU>*u%<las!W
z(MEH9Y$j3vf=ra$7vFzm1$d4E<xIw_vd|(s$~75}59`?eXJkXT&(weVpE#cJakZ(G
tA?yDl1u2V6uU;~qawdC^5G=|At&tKVnRbMnLup*RCc#%D&qzqd{{>Rxx6l9p

literal 0
HcmV?d00001

diff --git a/components/hostname.c b/components/hostname.c
new file mode 100644
index 0000000..23da677
--- /dev/null
+++ b/components/hostname.c
@@ -0,0 +1,16 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <unistd.h>
+
+#include "../util.h"
+
+const char *
+hostname(void)
+{
+	if (gethostname(buf, sizeof(buf)) < 0) {
+		warn("gethostbyname:");
+		return NULL;
+	}
+
+	return buf;
+}
diff --git a/components/hostname.o b/components/hostname.o
new file mode 100644
index 0000000000000000000000000000000000000000..bcc0e4dac33c26a140f7196c66589a60a76d949e
GIT binary patch
literal 1680
zcmb_cO=}Zj5S~q|typ8~2NbH1i{j@?*NakAl7@T;!Gf&^@sMufwt+Su?rt&BgNS&@
zq0oZ|e~kpZ_!DyT>eahY=h@68n<eoe4!n8idFGjUzb5-WUoIppi_|Q7Ok<=hQEG1N
zXF@kaNjgVcrK78WUumAG)cf%hAlvJgdV~C@em7<JOGl5ug#o+&^4p#p)LVW~?KYi;
zyG~Th<<`?Ticg>4Oxw1x%^K9GMrj_WcyNpoWc9(RS%P)1mn2}leMVL%WvwnPEFN?4
z3iBASd-%yFQy&xU<RbjP80yZ`uajw#xhXfa6biB1Niz&DMD*bvm|NzNnv{m<@(lj=
z4F3KMo^Z#wVN)Yh&aF}PaF;5@^5#aiT-huXw({GR?d(Q5Um<xAi0O^vHN$=AT_+gf
zRKHJ#hJC{jU*MtqHIQu3qg9l@1(FSV+_~~;_F>RtjLi7mM&MM*_<=W^>*{&#fnx%<
z6Oei31P+<1@00Ob0FZO{kg2sA4Y$dXW-D+Fx6WNZaBBO4_nL>M?X}vj7j!ul1>JgO
z*TdQWi>0{=dgpYkT1K$GzlODc6|b^`yUHjb^NL*3j^MLABUk%)MfmH&NB*v1#FKb@
zim!i%1*rM2`8MaGX8fGG{&|i?P1n~s!$J7NufSOOLEMXDD)cl@=O@gnAC-QNf`}j2
zzTg=8dZH&8f03N{zV!YjOt0BN&3OKI5j;?#%<=pK=BK@XM+)jY<NeR@(0t{mtsO2U
s2OWff2;VFHPlD2X)QrD9;seQl2oN!$M-09X)AEmH|L;c1p%c&l1Hm+oS^xk5

literal 0
HcmV?d00001

diff --git a/components/ip.c b/components/ip.c
new file mode 100644
index 0000000..70724eb
--- /dev/null
+++ b/components/ip.c
@@ -0,0 +1,60 @@
+/* See LICENSE file for copyright and license details. */
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <stdio.h>
+#include <string.h>
+#if defined(__OpenBSD__)
+	#include <sys/types.h>
+	#include <sys/socket.h>
+#elif defined(__FreeBSD__)
+	#include <netinet/in.h>
+	#include <sys/socket.h>
+#endif
+
+#include "../util.h"
+
+static const char *
+ip(const char *interface, unsigned short sa_family)
+{
+	struct ifaddrs *ifaddr, *ifa;
+	int s;
+	char host[NI_MAXHOST];
+
+	if (getifaddrs(&ifaddr) < 0) {
+		warn("getifaddrs:");
+		return NULL;
+	}
+
+	for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+		if (!ifa->ifa_addr) {
+			continue;
+		}
+		s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in6),
+		                host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
+		if (!strcmp(ifa->ifa_name, interface) &&
+		    (ifa->ifa_addr->sa_family == sa_family)) {
+			freeifaddrs(ifaddr);
+			if (s != 0) {
+				warn("getnameinfo: %s", gai_strerror(s));
+				return NULL;
+			}
+			return bprintf("%s", host);
+		}
+	}
+
+	freeifaddrs(ifaddr);
+
+	return NULL;
+}
+
+const char *
+ipv4(const char *interface)
+{
+	return ip(interface, AF_INET);
+}
+
+const char *
+ipv6(const char *interface)
+{
+	return ip(interface, AF_INET6);
+}
diff --git a/components/ip.o b/components/ip.o
new file mode 100644
index 0000000000000000000000000000000000000000..81b173c75f83acd4d94da98f64ef172c2c1ce26c
GIT binary patch
literal 2600
zcmbuBO>7%g5XZ+((wfq4160CNL9CFAj3_H_L5N18@;Y&{sW!Bb1gSu<9DAL(jXzj#
zAb|>0HLh5hAdZ|6$D9xnr}hw8A|P?A1P8>S%Ap6MfDlM<0b%C9ey`rF><f(Y-kbNE
znfE#SocFWVWHb^XDG@qHy`H2*TZejj+E>%0&@nPzG3E{L4`XhA*7W`|ul=kJ6BW(Y
z@TnwwnchYs&OmRQn^zMtYtv0U{1c+BRxuH4w%1RXn=hcRw|%_7Hq%NZW}0`8Z`@!y
z-MX5Ho6U~9ckyO~hq1ihv--D}BU!z@{RrFr7&ygD?~eDi-+lE`v%PwAx;2rAmnP08
zS3fsl_f5@T+(*4%eN{|rdf$kdv-;hA)$;y4xSnZmXa7iV0JGKIPSJd-yFYiNJKD7!
zY}@j7Ut2I<Hx`UHzS@rR`u6Vp)9Gv<f%ZLXOSW4s<%>n9F-ELc^A)>XE!D=<Qw`!j
zni?M;Q<GCK&OfQ@x~6L>4&-4;<ubyBEfl3l8%#<>^yQtM5QfM*FH>Y~G;;Fj;n>G)
zyvQ6!28qKtql|tO%_#BBp{$~QIBY1%8zY92x_;=qayu5CRep%gD7&!*ZViBSB{iWW
z4MpV;4$UYrqEQ~EjsaP)NeJfO@U<Qj-M$T$GEBd9`Wc7%WFpd#&)}ZBzZdS^=M$XL
zK~enf2pv6$=^?@8nMiY-73?c48iRiP>;Qgl06#x~zchd^4B(dsaAyF&&ip|>H+f$2
zzCIBAadD)QQ@O4cxFXFOPodILouS;6bs=L|xeJq%v)Q@aoRP7zIb^fQY<fHIRD;<~
z4c94D>Qr)UTly^J%Q?oj<J25ltUKkZTcRAJeBny2uzV#~%9mGo^0%Hv^&Bseo<YTe
z+~?GzzdKzS2V}wL2AkwKX9yT_L-O|kS-`PZ$u|L6!0+cG`4%7xIC4nxF9BJ=k8zRw
z79b1OgKU(12apB+!S#IS)2=^qTl)VfIQ)^rlJ5n0a6R$~hyU?_zbgE(9uz6AP$ZXm
zfqZ~SF7tx4#(KrgFLLWT-F8`Oj=hrCTzkzWt(bT7q%AfYq&YQo;LdLuX@y#)VprLv
zT61lUpR%X@>lXc`>Z(?EYIWOj*Etje+RM3;!%t*)J^!~>c>tt%;AhMqGVRwyr+ZI|
zPeNTf$rNXs_N~2Y3y|e`5rEu*iX4UDJ%K#I1$+pdfUJZk61Fft%^YL?*La;{G3FUA
zL6P%67KE(J`DL3HEEV!=35V``+B3>H*-nf2o<~>vR62wVVSI`0hq(lE7$Kht$MCx3
z`NIeDCKtGd<8O=jPv8`gaQq6}`rZGo_{lLvEbbrQw~Uwf-*0Y&EQ<wwA=ZI!8v6{#
mW6bc~Ga~$V1(EMpx7WKr*?)kQe(_21LA)y+MJtwbkNyiq^<&`x

literal 0
HcmV?d00001

diff --git a/components/kernel_release.c b/components/kernel_release.c
new file mode 100644
index 0000000..0457301
--- /dev/null
+++ b/components/kernel_release.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include <sys/utsname.h>
+#include <stdio.h>
+
+#include "../util.h"
+
+const char *
+kernel_release(void)
+{
+	struct utsname udata;
+
+	if (uname(&udata) < 0) {
+		warn("uname:");
+		return NULL;
+	}
+
+	return bprintf("%s", udata.release);
+}
diff --git a/components/kernel_release.o b/components/kernel_release.o
new file mode 100644
index 0000000000000000000000000000000000000000..31ffaa747951fc159fc5f10aa1d38761fbfa105f
GIT binary patch
literal 1872
zcmbtU&r4KM6h3d%v@$W13T!b84a2<nT8U7M$~Z3=GRhXM9?zL)BRX%U_nxE`gkVsJ
z;G#v#mMvSfYBf;Xz&|6XP5Z#kcfH4+mzfsz!M*pK?|kRn`|gkTqF7$YISvUNx<!9H
zVTlg9{@4X=7HELZk+=QhE$ge^Zui(Y^WN*7(N|2kEpPAnXzm-NFI!tf@NdG=jNAHt
z(cAkty2FIw-Ik7cyKi)U)teaB1=F4*e)|jN`MePY^>Bv95~9-l{7inlbmzgfyz44g
zO`&`@w>-BVZXBW<IW2Gk$M{@JW7v$&(|hD>4mu<Ky?y%}yuv&h&_q`nc-NJy4fMhO
z3sAS4ejc`ybhX*pAuYsePvVkxd#Lv$t=BY^siW7%nh9=$mKN@82foySFL&UVI`Fg>
z#!<NL$KiSyB%!L1D$h@$bFC2hrSjt3Y}sF2Sh!zY@|R}k%0-{_fzp#8j%c|VuSV$#
z`F@fHl{LRoTk}_f)peel^5_^iOYF(7!y`<BWaPNviVA-NBm;V!neauB4CoOP9^Vas
zJIzh_Do6(SGu(vFvkjmQ+A&nJRZoLuQb`&gjWw}&j{=p3n<=SkkOridlY~^<fCD*S
zVp5exy&gs^i5h9B_zF+z%`pC>XhSvQMl+1lElx$ju;#DC{3woB@LxurvvG${Syc+g
zm-{ARXtNk$2YXe>l5D>>o3wBEvpgbK-qU5nUp0K@ccUX8Oxzyq`LDA8HUBl=<y_R1
z`@^P&%#S;eh0HHwfrGH8vLd!W8UKRCOP-9kIWBfq`ZeohY+L(~V|X7Y?j-vMCdXcv
z?7s=qV>VFJ&X+|^i_naAJ|1hk^Pe^cBIk_r$2*gJ;oHv5x@q&FeP--u4u4HMA2sc>
dXNn5ugY0Kw%0Z%Wp8IzBcMbW>=wz_-e*;L}yFLH_

literal 0
HcmV?d00001

diff --git a/components/keyboard_indicators.c b/components/keyboard_indicators.c
new file mode 100644
index 0000000..b35eba1
--- /dev/null
+++ b/components/keyboard_indicators.c
@@ -0,0 +1,48 @@
+/* See LICENSE file for copyright and license details. */
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <X11/Xlib.h>
+
+#include "../util.h"
+
+/*
+ * fmt consists of uppercase or lowercase 'c' for caps lock and/or 'n' for num
+ * lock, each optionally followed by '?', in the order of indicators desired.
+ * If followed by '?', the letter with case preserved is included in the output
+ * if the corresponding indicator is on.  Otherwise, the letter is always
+ * included, lowercase when off and uppercase when on.
+ */
+const char *
+keyboard_indicators(const char *fmt)
+{
+	Display *dpy;
+	XKeyboardState state;
+	size_t fmtlen, i, n;
+	int togglecase, isset;
+	char key;
+
+	if (!(dpy = XOpenDisplay(NULL))) {
+		warn("XOpenDisplay: Failed to open display");
+		return NULL;
+	}
+	XGetKeyboardControl(dpy, &state);
+	XCloseDisplay(dpy);
+
+	fmtlen = strnlen(fmt, 4);
+	for (i = n = 0; i < fmtlen; i++) {
+		key = tolower(fmt[i]);
+		if (key != 'c' && key != 'n') {
+			continue;
+		}
+		togglecase = (i + 1 >= fmtlen || fmt[i + 1] != '?');
+		isset = (state.led_mask & (1 << (key == 'n')));
+		if (togglecase) {
+			buf[n++] = isset ? toupper(key) : key;
+		} else if (isset) {
+			buf[n++] = fmt[i];
+		}
+	}
+	buf[n] = 0;
+	return buf;
+}
diff --git a/components/keyboard_indicators.o b/components/keyboard_indicators.o
new file mode 100644
index 0000000000000000000000000000000000000000..e6e872382e0ad8f133611257c63415a164c71193
GIT binary patch
literal 2440
zcmbuA-*4Mg6vwaIv<;BCg(0nC(`2L!1wpNP8`7vWh@CWb!BA~&A!r-MO<Ypdu`}m}
zH88<Y)u~wsAOtUa+6&U25Pv}zse`@qG>I1;5I;1gX>WVj6wYz(&D<z{fg>IJ+|T`<
zbFY1`uRohLazlbZxC!Jn^0>t*A@R}2aXJXoL?ru&`mXwpx~wiO>y1ZBXHnn$r&QFN
zu_Gza=#6YLueAR{`F!K1zSXYn*IOsC$>`s^5bG_PoYWh)lwW6+yMfqf{AsjaL0!<?
ziJ_`-FKA?&7n3Qh95-Hdl5x5b&^N|+=oFdn{G>NQc|Y4s{+Mn2p<a4eprdegYrovU
zrwUR&N+=!e(#0wAdV2i3TS^=I$G>fN+S%tHY<1{!TWvZK6n$%a=Xa>5T{(VD-9CQ!
zP8@o!sN0FddS~~}=SJ%Y&QSe1c8KUrc+#T&Qun#(NRX~?-Ygl7-_D#<&#LFt_f>N@
zzfiH=>{_+rSoIkxXRSGQQKFvY0hWqgPRLv)Gb5$u-d=uDQWRN{r*Rm31rqoOICPOA
zBD9fl6Ih$C-LtGi`1mvtHYS9FiLv<C&}jfa#QLUCtcep}4Qb-!m&2MUwPKo>`eH;C
zr!SA@#1oriS@D`MoDjqlS#eqwQy>8;q-bKC6^XcE=@_}+8Pq*IV22$Dg!puO4d?ny
zNFU4@7`~K=z0#nSi{Oh9JRiZG2wsWcpGNS@5&UWd{~>~tb-TXeS$@%6bBk*Qi+X-l
zE)dzsOb_ZJ=A5yhsfM|b%Pr0>nM<l>%$g*;0m%i+cS(NErf;&+8PBD@=a7}!D#>RY
zuWGZsN~+X%9or?QS)lcbZBoziF4(^5c!dzFRVqDJrB-3xER@#GRoLc)B;mQxaL?jV
z^03pjV+g^9z=y#(pFs$Q`Y~|MPay<Dj$4rPGYG-3&J*CAe*iHW>YoJXyo?YG`BUJW
zZz2Rko&e|kHbOAu`@lJWgb=KM+ym@GM7;>k^%BHrs7LRaT&<U>wL)Zg*WG)GN51V?
zGPO4-k&70!h`ds*6502#fpRz`h+Oc>W!nXb>rq>VBVsC80@nV}t;rQ1&KaN9Ar%YS
zC3Drc%64xC|0|Fn8y`9Jn+WQqgDWBYyJgML7u_WX;fC)j-EH=+C4^vc_C9f~FyzP2
zBzA(m0FE5@P}s^WFU&CR$1elJn*TLlVKtA!J#2jZ;9n8y;N$aq8u~B}4*QVq8z$Hv
zVi@u~exDDqu=IN_2*Ux|_kiJdwr5X5`#Q_-pBI1sAPMX|Tv6Jef1Bl(y0YH2KOfKA
zLF->(zXZO{xc>Nk^L)++jg5n)*@Q}L9{5e;IQ{upvw!UYk?RcJz(&YexgL2MqCxrF
NZ2q70l--~||6ehXY03Zq

literal 0
HcmV?d00001

diff --git a/components/keymap.c b/components/keymap.c
new file mode 100644
index 0000000..ddf7a15
--- /dev/null
+++ b/components/keymap.c
@@ -0,0 +1,87 @@
+/* See LICENSE file for copyright and license details. */
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+#include <X11/XKBlib.h>
+#include <X11/Xlib.h>
+
+#include "../util.h"
+
+static int
+valid_layout_or_variant(char *sym)
+{
+	size_t i;
+	/* invalid symbols from xkb rules config */
+	static const char *invalid[] = { "evdev", "inet", "pc", "base" };
+
+	for (i = 0; i < LEN(invalid); i++) {
+		if (!strncmp(sym, invalid[i], strlen(invalid[i]))) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+static char *
+get_layout(char *syms, int grp_num)
+{
+	char *tok, *layout;
+	int grp;
+
+	layout = NULL;
+	tok = strtok(syms, "+:");
+	for (grp = 0; tok && grp <= grp_num; tok = strtok(NULL, "+:")) {
+		if (!valid_layout_or_variant(tok)) {
+			continue;
+		} else if (strlen(tok) == 1 && isdigit(tok[0])) {
+			/* ignore :2, :3, :4 (additional layout groups) */
+			continue;
+		}
+		layout = tok;
+		grp++;
+	}
+
+	return layout;
+}
+
+const char *
+keymap(void)
+{
+	Display *dpy;
+	XkbDescRec *desc;
+	XkbStateRec state;
+	char *symbols, *layout;
+
+	layout = NULL;
+
+	if (!(dpy = XOpenDisplay(NULL))) {
+		warn("XOpenDisplay: Failed to open display");
+		return NULL;
+	}
+	if (!(desc = XkbAllocKeyboard())) {
+		warn("XkbAllocKeyboard: Failed to allocate keyboard");
+		goto end;
+	}
+	if (XkbGetNames(dpy, XkbSymbolsNameMask, desc)) {
+		warn("XkbGetNames: Failed to retrieve key symbols");
+		goto end;
+	}
+	if (XkbGetState(dpy, XkbUseCoreKbd, &state)) {
+		warn("XkbGetState: Failed to retrieve keyboard state");
+		goto end;
+	}
+	if (!(symbols = XGetAtomName(dpy, desc->names->symbols))) {
+		warn("XGetAtomName: Failed to get atom name");
+		goto end;
+	}
+	layout = (char *)bprintf("%s", get_layout(symbols, state.group));
+	XFree(symbols);
+end:
+	XkbFreeKeyboard(desc, XkbSymbolsNameMask, 1);
+	if (XCloseDisplay(dpy)) {
+		warn("XCloseDisplay: Failed to close display");
+	}
+
+	return layout;
+}
diff --git a/components/keymap.o b/components/keymap.o
new file mode 100644
index 0000000000000000000000000000000000000000..d23e66dac4f30b96a717f237463e566a97a737cc
GIT binary patch
literal 4096
zcmb`JTWB0r7=X{_(xjSB(u*~<RYu%~NbQiVy`z%ZY?2eYwAG{<(YT%6oixi{-93qo
z78-~Zhc#BHi1?&$eNi6-1(A|AZS9NT4TLHvDA-b=?TfyM@&C_db9UT$DgJP7-}(Rl
zT<4#2axgyB6bca~A@T%SX(<Y2$4b4QSNlm9=_K|uk!Aa7`-nYuWR%YTLDRI_vb7f!
zs22<GjVxY6U3zM9dLvzU9P5$A!N_l%UiV-i>Rl2lqIbl*1j=kP^)8%iK}+u@?*`Vu
z!CLO%CS4c{_ngCN>#l6?G7S68NOiCeywGZ?i}#Lr7jZi4Yt!NM`ehib^V3+kCoU!u
z_kNFi|G*kLgwHQq!Z>^CEzwgyvR7jJSh(W^qYG;|twyL94|h}VFY2+d7>HJ(M!lb5
zDcl7tVHd5U)<P>cnm^x8_nn`<06Jof<tx)AQR_Uno>s}9vBRNuHUaa9EDP=}-I$}*
zo#Fb)!(3rrTw}!hDem3;98Zw%pERp&;--4b8>^|eC2TKWzVRNd!g;0XHgS5aRankn
zq;c<;=O*mu?Fst@JFzr=sN@!6nMx_=%<eaboJ`J5o2+OS0h?*T$#^zt=W@l=0e3c8
zbjoR6(ZLRfxn@>&qV}-M4mx?aqAQkNR?fIHT+yt|=99%-Me2?+a1f-+M>H#_LdL<d
z&5C(+uInFjndtyG3(!Hf?I&Bo^+2vzaT_cxg}k;lcP8!5kW9g4q?95_r{dya-nk49
z4D2_1hYuck*o;K1h}9=t;pI0W;Z=c7(nLaw$drU+8&4W#gD6Po<)=vKcvon1M_c<_
z&>085MfTl7<*3nhx+!LKzu6o$%!QVy(fdZLZS=ji$~N}Sx5bRPQ1iDTV{gppvyEO*
zi5lHt5;fYTlYjzUw~*V*jk=o~M-<Y`S66Rw7c@g;RSlZ88Ug(kuCQ1)|DY7&<tCoD
zlC5==kOw3m_3?)!Kk4JWl7Hmm+a>?r$9G8ngOBf#{Hl*X2JLm){_rybHUO#1r;E*J
z1NdYB&j#=l0sQp<{&oQWAb_6@;2#I@&jR?R0RB|~|1N<48o+M{a01~e@06?*eCjh!
zE|Z22(~1x9EP}Nim_3TwPRw>;wi~lO(v&2I<A<VlJaK4fXmoHaF=j{Og9)MsQ1X&f
zF8n82>H$#?cy-Z?R9Kl6vsmQZ0v3f-zC;p<6q_x%iDUwzEJ>EinF5<6<3nW^f?+m^
zr3%XR0S_!8WTvu-)KoSx31J=f1?53ez_%^#<KN3d#Qi4_mk9qV6&Lp$V*w#+At@e%
zItuc2kQ6_F5Cr|SK~g-05CrwtLsGne5CruxBq@FzA&7t6(*kpju|ny;BRTq6t?>^f
zM?d#y{0qrZA7hmAvn08HToo5k|87km?;#56Z-k`$s3#ceV>DBIBL-Fw)V~*!;yoJg
z*7$D8l^+%Rhc$iO&yyO*n5q0{G_KEcR`ZWfLZv^a>EEaEs>U~K{C$n%9F?E58oyuT
zpGc1DTBC9P)Pc5t|F3F(Fy<@&Q00Q%&5+c-<6S~gyiMAx7_4}Q<hbW3ig!wGaw_g8
z&b1~MJYkrVBo=<Syqr?CvYT@(<{oFnN;}LUR<cqdR=J1`REK8)G*O8Ys6nTN&!`-+
zQpJ4UEr4mE$XpAa3fuX2EZfHl(^jbrkFzqHl|J05#AF$tJ^zcC;02fN|1<XkLs9=T
z(Gt3<jwRj+JiC5Kx|s4nzLuMaXO82jb5i@?BRQU>E`4>IztSU*sRkZ_8v49b`v};g
zPx0S}iWD{e2H$|Hsmejn$GU&~qY{|XpDO(Ae&}elf44A5fgI(z_-62o{QEZ!49Azx
zPN_}EoE#rxuP$ods&t@J)pfly{sqZSzwV2`G4A`1>s@K@pO>1y8q0$U`t;jhk@izc
zQI>xDSAjR$zrz@`LDW6N`-e!`E8b{qwCh8sAlKx?45(xB+vC5d(N=Zirhqj0Hq6)L
S|JX+MQ*!=igqvFKxBnNrM71mc

literal 0
HcmV?d00001

diff --git a/components/load_avg.c b/components/load_avg.c
new file mode 100644
index 0000000..5c2e252
--- /dev/null
+++ b/components/load_avg.c
@@ -0,0 +1,18 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "../util.h"
+
+const char *
+load_avg(void)
+{
+	double avgs[3];
+
+	if (getloadavg(avgs, 3) < 0) {
+		warn("getloadavg: Failed to obtain load average");
+		return NULL;
+	}
+
+	return bprintf("%.2f %.2f %.2f", avgs[0], avgs[1], avgs[2]);
+}
diff --git a/components/load_avg.o b/components/load_avg.o
new file mode 100644
index 0000000000000000000000000000000000000000..0287b71ef62d6cab859845f260a1a89e849345ed
GIT binary patch
literal 1904
zcmbu9%}*0S6u{q>B2^J95<`N9Jrq;F#x98mNi^l7r6yGpEQwxRx9zqi&~Dw12zu~9
zJP=~SpTb{Yn&`p*M2#NQGYP)8owqFmO^m)|I`947$4uwV?AuH}8!-%EG2lLQEv5iJ
z2fBJXP}491=ODNJBl&@R<=k#`Dv3&NXCX0ewR1aPzEa$~_SPs`@9&Wj5Uc%t^7r|8
zArZ&ld?KcN`vYi36G2FBw~!bw=WdJz73E+DZhuOCth#dDbIQ&}b;is(tLtvrl%DAo
zrL)>F$zwVjuJ2S`m=e<!GyDNqoS&aDlZ%g5u9=o4ERmuOK@^9HV-N@WAOc347@vWm
z?9<3d#yS%iub08tj2jcfL$N&!CVpA@nlvwrq#|o0F@=szR6h#84v#qy41}w9y~BY@
zyF4lv0&@_qAH{G9?a`h(!Jd#!;)rXpWZvn+(|vfR4}aK)1NFwnwuusm{CtXjtPp~|
zm|vQk&D%@a?Bh(qF3is5Gd6Ua4X+%(0mY`j+K?5n?Ur;(Yj&x&W>@eM;F?!(kWlZ2
za2y<VgwG{{jIJs3+o+RJJT-}VmLLknlaKi_K@?(i7noNGq7XlWgSm-13DuzyifC=s
zrBejal745dvF5w$j*#xA1W|UR1ESb!f$%*tC>(Dsh>};YyA2F!c+wSkWp4#%q3mko
zrD*zI)Ai*Rrcyz-W><Wt?uI+~FU7=cy1S>eDrsf&J!3b&Beo|{p|eUeQ1fSXNPEgY
zi!<f&0~%NSs^UGLqrkJT{Q9J?e-i_!=D+4!m`gRMar6qWf43K+&g=7>RxG8(eN*;D
zjdLE)4^+Mu1_wG&Hs`VXDJt|nj@(Idsz7~TeEt+d@&X5i>iMa^%%`_{QvaW*hH#&$
z|MbpyedZ^vjbZRytshe}eJ|;2spnHoz4wTqrvA_~GI~Un3kiL1Ps(p9_$G|(D0==M
D#3{%~

literal 0
HcmV?d00001

diff --git a/components/netspeeds.c b/components/netspeeds.c
new file mode 100644
index 0000000..0029177
--- /dev/null
+++ b/components/netspeeds.c
@@ -0,0 +1,139 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <limits.h>
+
+#include "../util.h"
+
+#if defined(__linux__)
+	#include <stdint.h>
+
+	const char *
+	netspeed_rx(const char *interface)
+	{
+		uintmax_t oldrxbytes;
+		static uintmax_t rxbytes;
+		extern const unsigned int interval;
+		char path[PATH_MAX];
+
+		oldrxbytes = rxbytes;
+
+		if (esnprintf(path, sizeof(path),
+		              "/sys/class/net/%s/statistics/rx_bytes",
+		              interface) < 0) {
+			return NULL;
+		}
+		if (pscanf(path, "%ju", &rxbytes) != 1) {
+			return NULL;
+		}
+		if (oldrxbytes == 0) {
+			return NULL;
+		}
+
+		return fmt_human((rxbytes - oldrxbytes) * 1000 / interval,
+		                 1024);
+	}
+
+	const char *
+	netspeed_tx(const char *interface)
+	{
+		uintmax_t oldtxbytes;
+		static uintmax_t txbytes;
+		extern const unsigned int interval;
+		char path[PATH_MAX];
+
+		oldtxbytes = txbytes;
+
+		if (esnprintf(path, sizeof(path),
+		              "/sys/class/net/%s/statistics/tx_bytes",
+		              interface) < 0) {
+			return NULL;
+		}
+		if (pscanf(path, "%ju", &txbytes) != 1) {
+			return NULL;
+		}
+		if (oldtxbytes == 0) {
+			return NULL;
+		}
+
+		return fmt_human((txbytes - oldtxbytes) * 1000 / interval,
+		                 1024);
+	}
+#elif defined(__OpenBSD__) | defined(__FreeBSD__)
+	#include <string.h>
+	#include <ifaddrs.h>
+	#include <sys/types.h>
+	#include <sys/socket.h>
+	#include <net/if.h>
+
+	const char *
+	netspeed_rx(const char *interface)
+	{
+		struct ifaddrs *ifal, *ifa;
+		struct if_data *ifd;
+		uintmax_t oldrxbytes;
+		static uintmax_t rxbytes;
+		extern const unsigned int interval;
+		int if_ok = 0;
+
+		oldrxbytes = rxbytes;
+
+		if (getifaddrs(&ifal) == -1) {
+			warn("getifaddrs failed");
+			return NULL;
+		}
+		rxbytes = 0;
+		for (ifa = ifal; ifa; ifa = ifa->ifa_next) {
+			if (!strcmp(ifa->ifa_name, interface) &&
+			   (ifd = (struct if_data *)ifa->ifa_data)) {
+				rxbytes += ifd->ifi_ibytes, if_ok = 1;
+			}
+		}
+		freeifaddrs(ifal);
+		if (!if_ok) {
+			warn("reading 'if_data' failed");
+			return NULL;
+		}
+		if (oldrxbytes == 0) {
+			return NULL;
+		}
+
+		return fmt_human((rxbytes - oldrxbytes) * 1000 / interval,
+		                 1024);
+	}
+
+	const char *
+	netspeed_tx(const char *interface)
+	{
+		struct ifaddrs *ifal, *ifa;
+		struct if_data *ifd;
+		uintmax_t oldtxbytes;
+		static uintmax_t txbytes;
+		extern const unsigned int interval;
+		int if_ok = 0;
+
+		oldtxbytes = txbytes;
+
+		if (getifaddrs(&ifal) == -1) {
+			warn("getifaddrs failed");
+			return NULL;
+		}
+		txbytes = 0;
+		for (ifa = ifal; ifa; ifa = ifa->ifa_next) {
+			if (!strcmp(ifa->ifa_name, interface) &&
+			   (ifd = (struct if_data *)ifa->ifa_data)) {
+				txbytes += ifd->ifi_obytes, if_ok = 1;
+			}
+		}
+		freeifaddrs(ifal);
+		if (!if_ok) {
+			warn("reading 'if_data' failed");
+			return NULL;
+		}
+		if (oldtxbytes == 0) {
+			return NULL;
+		}
+
+		return fmt_human((txbytes - oldtxbytes) * 1000 / interval,
+		                 1024);
+	}
+#endif
diff --git a/components/netspeeds.o b/components/netspeeds.o
new file mode 100644
index 0000000000000000000000000000000000000000..db5a6709b4ec7fb5c7e53f9da1f121c3ec4c7750
GIT binary patch
literal 2800
zcmdUv&x;&I6vtoBZjzNG<3=McL}dcIk{{ZW4tP<K*(|%;%8-O?0!kuH?`)4d?#%4i
zRU2mXAVH%n!-AlP`~!-|fHx0eAOSsj@Fe7r90L(GCl!SCeS7Nd6ty#Y@Z^K)di8nl
zRlTZuT_4Vu7jm9QA|Aa)gOO08*1myW%G46&=^$MSH~$Q`o&vc=lSE75wV$WB54+ET
zt%Tk2nPaSkn;%b4Fb{g+R(*OR-2C+c?ALpp@u2tc4d85&aO)*-v4_|1>U-PYZ`=*L
zd%(K~@eO{wMdR#r{HL(idoae@?~lUG@3I-g?iblYE8)q**~)rPpI^I!ye_|e`+t}+
zQBieNu~LtfDmD{coKZ!kV_j3aR#C;Y9W8fsqG;ybjeqvk;z^5hb1xT;EuOt}ybuI_
z;Ge?55{{J$+;G}#q#SuYFcHs;rA7`LgZKUg^4gQ$kpufCK4T;9{262W2K{V)@{`>8
z{M1Kdi}{;{+>QJcliB<Po8TM5hvnaV`(C@h$Y-1$ZSS@ajSa16aC>L{NYt0d9C<;c
zf0}i05#dKOkkzJ`vi^C)`~ARl((n@llxaBrC#*cPb71x=H!j;<a$y9&GJ;n|@cIaT
zbp-#EIr5bJq$jRQ)k=~T<yR<eXXWSzq>Xlp{PJA(380<cagWkAMT_NgXJ*UMxrK$L
z`HRuT*)!$&h!WLorM0H6QcG3hW|de^(yMWustp~jZZzU1MG^l6m9?m{x)xRAT759B
zZgZk6@@(Z;-^=Z<?Y<m=kp-L|ke!=-1&{?dy`P)-mjPK^|D`_8IMx#X%Z6i~0~TL1
z+@0q=i=zf*o-M;MPu}8RTKsW~e``4AM~%unKUf_575<Ci?tbM*l03zKule!8?fvEr
zclZ08<!`S$ZE<_QC2Jmgzi(RH-fzL=k9^QX?E3=WsZ(Ed8aiGkU+J{puZor?_1M=*
zTa&*M>zMpyrN~d$F@QTiljK*{8;zvNF3okF`20k^n3bRzzti0CTj_c$Np*)qF=4VA
zRnxeUNM`@7FK{@H0<~;Q$qcIIoW$k~33ZP<Dv5*X?*p>jHvy=9sPfKD!N`L53><f9
z%UA9~#^~Y~m}5>i{%hmtzIC#`tQD{V*V6(_FY)IcF6&EQVmoxax3>IY9G<ix>k=pZ
z>lU+J_uIv186-~7Tdd%}aor~kaPxBak9Pudy746gT5Pk$jjywD*!}lRLCN~K|HrsV
xyxjk=wXxn!v;GaUVZ3?6;=$azM|^1N?{f?+anJ7%+lIyeX7c~QiiPUN{|z^Tn^yn;

literal 0
HcmV?d00001

diff --git a/components/num_files.c b/components/num_files.c
new file mode 100644
index 0000000..fb55df9
--- /dev/null
+++ b/components/num_files.c
@@ -0,0 +1,31 @@
+/* See LICENSE file for copyright and license details. */
+#include <dirent.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../util.h"
+
+const char *
+num_files(const char *path)
+{
+	struct dirent *dp;
+	DIR *fd;
+	int num;
+
+	if (!(fd = opendir(path))) {
+		warn("opendir '%s':", path);
+		return NULL;
+	}
+
+	num = 0;
+	while ((dp = readdir(fd))) {
+		if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
+			continue; /* skip self and parent */
+		}
+		num++;
+	}
+
+	closedir(fd);
+
+	return bprintf("%d", num);
+}
diff --git a/components/num_files.o b/components/num_files.o
new file mode 100644
index 0000000000000000000000000000000000000000..2f800b1895e3012c22f1f4062d9352d0273e5eac
GIT binary patch
literal 2192
zcmbu9OHUI~6vyur5acmd@Iitm;{vHcCk)1gB$^IwVMrQ?JPe3UGqi&=_T|hFK^Mjl
zNt)P%g$qAU6J7WL+-ltUiWqk;BzXSQd&@9sH~LS`+;e~DF^_xaK1(F0LXyOUBzBt}
z%>-pE+;QYbJvYi^*2navg!V&UTrw&L3r6)KB6q*wI#YRTyr{X$$;xMMj>)J|-54+`
zAC1aSj}iK0RBs?%pq<~6zVqSm`#Vv$60hv98r54!N@+FyzMlG8FWA>=oO{jgX|>f9
z!f#4ttC-E%%E+)YGQm`)s%$vR*mNv5p+u%<m#!$9rfTXK+O(4?WOzLau@IALU_ug~
zi*Is<2c#$SOxg-dL%p3{dlXC(zrbU!Fiy(hYA7KOzHHNFWw$*pM|L_4c`P*BEl1+A
zV#tGWIXo$MC3@!NNK96Ad5}s7@Fpz=JV!hGb=WN2)@0@Syu=P#tK;hDJbWCp^PCR^
zc>Udcn}EkJ(b(_1ulMf6M#+M`QKGltGcEX?7JRt{H(T&r3(kt0h4gwZZ#im)smYjz
z%Q!CAaTz;`v-EUwZc<OC=cc9>5{v0YeKMIyGrrlFZJAlxbj)$>Orgv&`I2K{zE-w#
zMR%P&Htixk!znT-MAk<3=diA`fF$g_lVpMq1CqeI$ppU%NCNL66Fd$`LVv^r$Nq$Z
z`KdbgcrW=PAKwc?AFR6I&jCr`C&&cf1tg(A_L|_EfFyA2MZp#FA@qSYq&nLL*IZ*N
zeaQN_Aw1j4o2qMVxlGNPuF2Fj$6=~n!UXB`Q!_PFDio|Dr4&o9rP42b&2i1lLq2~{
z+*Hdpt(om^Qz;r+8|ii1ELe>v_%BDHYKaWr#;+)!i2p;xkn7hFP4KOven@^9n}yWH
z3$W&J#c?r+An7t0I8O)i^j<iDF?j#06i3g0t=Fg)J;%xX68AsnhvbX<i!sWXcR2fU
zzi~f!E{QrZ;v5maubdtDCq6%zyF#%}vSWJ^`8+ZBT;ls91$sn=)L{J>uirqDPr>>;
z#hR`E79dHiGu9vHgs2z1*}YNsTHK$H_}B5C!Fu!zu05d!#2MxnZ`VMl$!k`>$DjXc
KBeU)V>;D47a|xXQ

literal 0
HcmV?d00001

diff --git a/components/ram.c b/components/ram.c
new file mode 100644
index 0000000..47e6fda
--- /dev/null
+++ b/components/ram.c
@@ -0,0 +1,222 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+
+#include "../util.h"
+
+#if defined(__linux__)
+	#include <stdint.h>
+
+	const char *
+	ram_free(void)
+	{
+		uintmax_t free;
+
+		if (pscanf("/proc/meminfo",
+		           "MemTotal: %ju kB\n"
+		           "MemFree: %ju kB\n"
+		           "MemAvailable: %ju kB\n",
+		           &free, &free, &free) != 3) {
+			return NULL;
+		}
+
+		return fmt_human(free * 1024, 1024);
+	}
+
+	const char *
+	ram_perc(void)
+	{
+		uintmax_t total, free, buffers, cached;
+
+		if (pscanf("/proc/meminfo",
+		           "MemTotal: %ju kB\n"
+		           "MemFree: %ju kB\n"
+		           "MemAvailable: %ju kB\n"
+		           "Buffers: %ju kB\n"
+		           "Cached: %ju kB\n",
+		           &total, &free, &buffers, &buffers, &cached) != 5) {
+			return NULL;
+		}
+
+		if (total == 0) {
+			return NULL;
+		}
+
+		return bprintf("%d", 100 * ((total - free) - (buffers + cached))
+                               / total);
+	}
+
+	const char *
+	ram_total(void)
+	{
+		uintmax_t total;
+
+		if (pscanf("/proc/meminfo", "MemTotal: %ju kB\n", &total)
+		    != 1) {
+			return NULL;
+		}
+
+		return fmt_human(total * 1024, 1024);
+	}
+
+	const char *
+	ram_used(void)
+	{
+		uintmax_t total, free, buffers, cached;
+
+		if (pscanf("/proc/meminfo",
+		           "MemTotal: %ju kB\n"
+		           "MemFree: %ju kB\n"
+		           "MemAvailable: %ju kB\n"
+		           "Buffers: %ju kB\n"
+		           "Cached: %ju kB\n",
+		           &total, &free, &buffers, &buffers, &cached) != 5) {
+			return NULL;
+		}
+
+		return fmt_human((total - free - buffers - cached) * 1024,
+		                 1024);
+	}
+#elif defined(__OpenBSD__)
+	#include <stdlib.h>
+	#include <sys/sysctl.h>
+	#include <sys/types.h>
+	#include <unistd.h>
+
+	#define LOG1024 10
+	#define pagetok(size, pageshift) (size_t)(size << (pageshift - LOG1024))
+
+	inline int
+	load_uvmexp(struct uvmexp *uvmexp)
+	{
+		int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
+		size_t size;
+
+		size = sizeof(*uvmexp);
+
+		if (sysctl(uvmexp_mib, 2, uvmexp, &size, NULL, 0) >= 0) {
+			return 1;
+		}
+
+		return 0;
+	}
+
+	const char *
+	ram_free(void)
+	{
+		struct uvmexp uvmexp;
+		int free_pages;
+
+		if (load_uvmexp(&uvmexp)) {
+			free_pages = uvmexp.npages - uvmexp.active;
+			return fmt_human(pagetok(free_pages, uvmexp.pageshift) *
+			                 1024, 1024);
+		}
+
+		return NULL;
+	}
+
+	const char *
+	ram_perc(void)
+	{
+		struct uvmexp uvmexp;
+		int percent;
+
+		if (load_uvmexp(&uvmexp)) {
+			percent = uvmexp.active * 100 / uvmexp.npages;
+			return bprintf("%d", percent);
+		}
+
+		return NULL;
+	}
+
+	const char *
+	ram_total(void)
+	{
+		struct uvmexp uvmexp;
+
+		if (load_uvmexp(&uvmexp)) {
+			return fmt_human(pagetok(uvmexp.npages,
+			                         uvmexp.pageshift) * 1024,
+			                 1024);
+		}
+
+		return NULL;
+	}
+
+	const char *
+	ram_used(void)
+	{
+		struct uvmexp uvmexp;
+
+		if (load_uvmexp(&uvmexp)) {
+			return fmt_human(pagetok(uvmexp.active,
+			                         uvmexp.pageshift) * 1024,
+			                 1024);
+		}
+
+		return NULL;
+	}
+#elif defined(__FreeBSD__)
+	#include <sys/sysctl.h>
+	#include <sys/vmmeter.h>
+	#include <unistd.h>
+	#include <vm/vm_param.h>
+
+	const char *
+	ram_free(void) {
+		struct vmtotal vm_stats;
+		int mib[] = {CTL_VM, VM_TOTAL};
+		size_t len;
+
+		len = sizeof(struct vmtotal);
+		if (sysctl(mib, 2, &vm_stats, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		return fmt_human(vm_stats.t_free * getpagesize(), 1024);
+	}
+
+	const char *
+	ram_total(void) {
+		long npages;
+		size_t len;
+
+		len = sizeof(npages);
+		if (sysctlbyname("vm.stats.vm.v_page_count", &npages, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		return fmt_human(npages * getpagesize(), 1024);
+	}
+
+	const char *
+	ram_perc(void) {
+		long npages;
+		long active;
+		size_t len;
+
+		len = sizeof(npages);
+		if (sysctlbyname("vm.stats.vm.v_page_count", &npages, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		if (sysctlbyname("vm.stats.vm.v_active_count", &active, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		return bprintf("%d", active * 100 / npages);
+	}
+
+	const char *
+	ram_used(void) {
+		long active;
+		size_t len;
+
+		len = sizeof(active);
+		if (sysctlbyname("vm.stats.vm.v_active_count", &active, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		return fmt_human(active * getpagesize(), 1024);
+	}
+#endif
diff --git a/components/ram.o b/components/ram.o
new file mode 100644
index 0000000000000000000000000000000000000000..011426bc6cb1224793fc1e9698c68f9f76579317
GIT binary patch
literal 3128
zcmchYO>7%Q6vxL-(wfk&LWxkMa@d1|93^bCrIe`R!_J2@kz5)<klG4Z*7mwi<F(!O
zZq-604p9%571SdV5}e@7krQ$Sf^q{c^oTeB5^(4RiUbPpzn*EPlMSFE@ud0s&Aj(!
z-kaHdbE#BJr&3HxiapDAN0Ku3QD(QFkGpwhu)~aR{XD_9p9JCC&!DOD-tc4&<L+WM
zWA}OYyOr*jy!+LUm@RbscE7N7XDB+tdrxOSX2Z1b#t)<MB=4<dGgUr49_xoA1Gx3+
z#3$rt?r+@W?0#u`F-tosWykn7SvlRkvC0YMR_%Ul=KMM7dL%l@d!=lKU;84Q;oX~j
z8k$s%*<YhE#X<N+zsi5R&AXoo6WCrZVS97f-akh{p1-hjGaBD}_@B}gtN$qglf1V{
z0qD`e2N@Wm)AOm%`Sd0oUrk5yc~5)(S}SxLr_9NVk-0HHN}w2co;ogEcGnwjxv>k`
zv3Ag^9P>SYy;*Cq`!g~h)oNbQx$9}ct<=5h-65N-?lsKV^1{L?Gq?QwOH-z8TedZe
zy9lA{$4n|CRA`!|S*i~vB_+o4O^l0))ax&>)RnQ+(L)C_*J%>`Q89M`?V@3(%SOhe
z?g@-Z-b1x$<S!Y#XsmLB7mR%Rype(KS<I1?Q9<{Wfo>aPlDAOlx+_KoI7zVIVRm~b
zX>KUtg&&L;A`17)p?EmLp1K#ahXh~J_#=Y9qw%AHzpHVR#z&O>#IYkbMP-bNF3%B2
z;>CUV>OR~h4!_c0oEu^n_gNo^^#{a7i1S2jQ}DXrah`~=!1b*Pvq}rIsBBcnQ9Xg`
z1g4!Dy%^>!m(I)=O3s;L@x`SzXRR<_T5?#sQ*oO$R`Wxr9{FyQIZh{ZD;rLwzTwp9
zVZ{d8UQl7>cCg+IYcUA%DC1t#@v7LyAg_$>HDg0m{@59afk_f@+;_=m07<|`sYt#8
zNCN&K70F)(Bmu`=k-P~=0{ggCl1G3fy5IK)c#q$21jqUVRHU8wV@hNA#aSf(lll;S
zKZiwrU<Wag>&F!i9m!_|2UFuvRJa-kN8xH5T8e!&4wn_K`u#w$qx!w2aMkZG3RnG_
zv~LK`iy~!CbR?Je|7DHKdmd_B-g9PkuKJ-{rZx-)ZC&;Pui;vucO_(2)eT){l{+0~
z1uYD)oIb$Js<eFHYtoWtEA%Y-^gbS6a528nj4b+D&;<{#k}3>(b$T$a@5z(=x7H+e
zgbsH~mAn}ID&i{Vv?0Uy40+4T1)}{HNhY}?6p$-)<%fC#lO&H(0mqwE<)oS{WkUCl
zcM6;Lt8bGoY#yhgiuC`X3aKys%Qi3AthVlZvHyoPF7;%K?}_ZIOMm~D=RZeEc*lE|
zi-73+lJS?mE>Q>mb^TePe_bvVt*+l7o|OMv;)DB|&_n(opd$5U{*!z|r7!%yErNqL
k4P9LyHuc;SVrRwuyM}=xdaUvPPST$fj^0po(be_;0-i7ap8x;=

literal 0
HcmV?d00001

diff --git a/components/run_command.c b/components/run_command.c
new file mode 100644
index 0000000..e00b478
--- /dev/null
+++ b/components/run_command.c
@@ -0,0 +1,30 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+#include <string.h>
+
+#include "../util.h"
+
+const char *
+run_command(const char *cmd)
+{
+	char *p;
+	FILE *fp;
+
+	if (!(fp = popen(cmd, "r"))) {
+		warn("popen '%s':", cmd);
+		return NULL;
+	}
+	p = fgets(buf, sizeof(buf) - 1, fp);
+	if (pclose(fp) < 0) {
+		warn("pclose '%s':", cmd);
+		return NULL;
+	}
+	if (!p) {
+		return NULL;
+	}
+	if ((p = strrchr(buf, '\n'))) {
+		p[0] = '\0';
+	}
+
+	return buf[0] ? buf : NULL;
+}
diff --git a/components/run_command.o b/components/run_command.o
new file mode 100644
index 0000000000000000000000000000000000000000..0394b194c547935358f9ab401818c352f384e22e
GIT binary patch
literal 2176
zcmbuAPfrt35WuG`2r8@y9xxcQ2N6Wsv_vl?nr@+Gi5o$o2NlvR?Up9eKW?`X^dN}=
zvxzl+20jRB#P}t=5M!c=iN>=MoY}r9%d)-bB(HDgH#2YE-|fq!o(hLTz!HKxaAYyX
zzVk?ryJ{RH=mj;c)o+olE~Yi-VB!8ZGG?6*+E$}BpgBLZ`fVbyhU@sA*X!eCYtH-K
z!w7)x{B#|<^Hp>9Ty?9l5s)~hZGEzbch6uh=U@pt@)2OutpIv`m`1KelCdw3bZ7tZ
zvbv-$?^#eOSIm+;GF%;*gi3a;Ts4IOGgDKO^61RH^ffsaQ({UKI&cIT8!Z<(gdx-*
z#u5@X@6iR}2t9uQq4mDdP)}F)J9OSeeo6Rts82|J_3*4T_$H!C@^;6xH2SJjm7?L-
z(&)4#tI{9_B&2SUa-ySp9q{Y$gabh&;Ka_kfu2JXiOu<T;<}E@MG-F@$8Z_#e$V*s
zT9A!l>+{8u8OIjHQ*HR&HhiuPPq*PqZ8%u9QYKq27L8I)$%3L!Md>F-KNDUjWM=fa
zgsNxeQmKXHVrEfI=*dj;?!Ys{D#1!E5BXKou8K<pRok+%1q&-5JrCMfyw>pNuqplI
zM4>xGhs*p5K@^H7AM@)3QHY(!#+>dG3B}VJU_MO{h2qa*V@~@=Lc9kX^JRi4G!ESk
z<~f2W6z{FO?$RdjMV;ff1?Tzv7VCZM;~X!0IOViNscsZ)V+9o4&1PR<%`(>v#WvS%
zP;!QCfU;7pf?}1)pm2P#pwQWxB@8K*ZBxM~J6^So>=R+HmTF4H!uN048<<K1nuSc>
zGKywv2LGkVm`!i<ly8){uy=f%zZ;B)P@z4KGZ4K-mk31`33Rrk@&{s&oG4eZ5f|Zv
zT=~q3ulLu#fqokEU-M&_OJh!8^9t9e^?8Nsb00@1=}~VG>IcFe@Nv%Leir?#dqewz
zU_k6cWL?<8-elA{-#;(je-3|&3YGHb$3^{l4ivpVe+_xi`4<SH@Hx}@)4Sw+=0UY7
vkN$&5=0#860J@|8d>Ye#_K09#EGS2YN5pU~avrsy{7o_c7p=&q;?MsJUTY13

literal 0
HcmV?d00001

diff --git a/components/separator.c b/components/separator.c
new file mode 100644
index 0000000..40fec52
--- /dev/null
+++ b/components/separator.c
@@ -0,0 +1,10 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdio.h>
+
+#include "../util.h"
+
+const char *
+separator(const char *separator)
+{
+    return separator;
+}
diff --git a/components/separator.o b/components/separator.o
new file mode 100644
index 0000000000000000000000000000000000000000..e9bf5ea90c08b5916eb8e9da716c5507972eef51
GIT binary patch
literal 1200
zcmbVKJxc>Y5S>e+i5kH#Fc6Dash~?z*jUIxj7cFDf@mYUiE9FyT)0~yv9Z<8pJHh#
z_>1i9bSAfRZkB-Hz~0PzJ8x!p=N@ZEhbhkkHV^jU7cmR)YLWhk_8|{*(0Km(fO@sM
zSK6!}pKg^Z6;TmofDGo8a82RD4M>6aP8^$OFqd618{WeSc!LG6n9t^3aFh5ovuEqM
zj_avj20p)Co^X1?&E}C`viPJ&r1~<HItWDzk~qE-)k>K~@yJ9p>}uHr5$Q1Y9gegb
zXb{&@OAyT{0?`V(UDZRb7icB$d3GW#Tek+cd-tLr27MLkA&5}jNufHIH=*n*ZuWm)
zL@B+|v{S-2IJv*UJReS9$AGvr6UHAnn4zoRz>OTP|LV6<OEvKq8#C^|JjTYkMDaOx
zt=LXIvw;<}j;R_3SzI)K+s+Me&qa5&?E(SSboEar=`TI?p&9umpIzA;v|xxC^mI<{
x&-|p`BzdC`+STX_FpHjM<m#!eJ3EpTO#f8^mKi!>7BQNnZ<xe(k{JiC{s%7_Ltp>^

literal 0
HcmV?d00001

diff --git a/components/swap.c b/components/swap.c
new file mode 100644
index 0000000..2509db1
--- /dev/null
+++ b/components/swap.c
@@ -0,0 +1,284 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../util.h"
+
+#if defined(__linux__)
+	static int
+	get_swap_info(long *s_total, long *s_free, long *s_cached)
+	{
+		FILE *fp;
+		struct {
+			const char *name;
+			const size_t len;
+			long *var;
+		} ent[] = {
+			{ "SwapTotal",  sizeof("SwapTotal") - 1,  s_total  },
+			{ "SwapFree",   sizeof("SwapFree") - 1,   s_free   },
+			{ "SwapCached", sizeof("SwapCached") - 1, s_cached },
+		};
+		size_t line_len = 0, i, left;
+		char *line = NULL;
+
+		/* get number of fields we want to extract */
+		for (i = 0, left = 0; i < LEN(ent); i++) {
+			if (ent[i].var) {
+				left++;
+			}
+		}
+
+		if (!(fp = fopen("/proc/meminfo", "r"))) {
+			warn("fopen '/proc/meminfo':");
+			return 1;
+		}
+
+		/* read file line by line and extract field information */
+		while (left > 0 && getline(&line, &line_len, fp) >= 0) {
+			for (i = 0; i < LEN(ent); i++) {
+				if (ent[i].var &&
+				    !strncmp(line, ent[i].name, ent[i].len)) {
+					sscanf(line + ent[i].len + 1,
+					       "%ld kB\n", ent[i].var);
+					left--;
+					break;
+				}
+			}
+		}
+		free(line);
+		if (ferror(fp)) {
+			warn("getline '/proc/meminfo':");
+			return 1;
+		}
+
+		fclose(fp);
+		return 0;
+	}
+
+	const char *
+	swap_free(void)
+	{
+		long free;
+
+		if (get_swap_info(NULL, &free, NULL)) {
+			return NULL;
+		}
+
+		return fmt_human(free * 1024, 1024);
+	}
+
+	const char *
+	swap_perc(void)
+	{
+		long total, free, cached;
+
+		if (get_swap_info(&total, &free, &cached) || total == 0) {
+			return NULL;
+		}
+
+		return bprintf("%d", 100 * (total - free - cached) / total);
+	}
+
+	const char *
+	swap_total(void)
+	{
+		long total;
+
+		if (get_swap_info(&total, NULL, NULL)) {
+			return NULL;
+		}
+
+		return fmt_human(total * 1024, 1024);
+	}
+
+	const char *
+	swap_used(void)
+	{
+		long total, free, cached;
+
+		if (get_swap_info(&total, &free, &cached)) {
+			return NULL;
+		}
+
+		return fmt_human((total - free - cached) * 1024, 1024);
+	}
+#elif defined(__OpenBSD__)
+	#include <stdlib.h>
+	#include <sys/swap.h>
+	#include <sys/types.h>
+	#include <unistd.h>
+
+	static int
+	getstats(int *total, int *used)
+	{
+		struct swapent *sep, *fsep;
+		int rnswap, nswap, i;
+
+		if ((nswap = swapctl(SWAP_NSWAP, 0, 0)) < 1) {
+			warn("swaptctl 'SWAP_NSWAP':");
+			return 1;
+		}
+		if (!(fsep = sep = calloc(nswap, sizeof(*sep)))) {
+			warn("calloc 'nswap':");
+			return 1;
+		}
+		if ((rnswap = swapctl(SWAP_STATS, (void *)sep, nswap)) < 0) {
+			warn("swapctl 'SWAP_STATA':");
+			return 1;
+		}
+		if (nswap != rnswap) {
+			warn("getstats: SWAP_STATS != SWAP_NSWAP");
+			return 1;
+		}
+
+		*total = 0;
+		*used = 0;
+
+		for (i = 0; i < rnswap; i++) {
+			*total += sep->se_nblks >> 1;
+			*used += sep->se_inuse >> 1;
+		}
+
+		free(fsep);
+
+		return 0;
+	}
+
+	const char *
+	swap_free(void)
+	{
+		int total, used;
+
+		if (getstats(&total, &used)) {
+			return NULL;
+		}
+
+		return fmt_human((total - used) * 1024, 1024);
+	}
+
+	const char *
+	swap_perc(void)
+	{
+		int total, used;
+
+		if (getstats(&total, &used)) {
+			return NULL;
+		}
+
+		if (total == 0) {
+			return NULL;
+		}
+
+		return bprintf("%d", 100 * used / total);
+	}
+
+	const char *
+	swap_total(void)
+	{
+		int total, used;
+
+		if (getstats(&total, &used)) {
+			return NULL;
+		}
+
+		return fmt_human(total * 1024, 1024);
+	}
+
+	const char *
+	swap_used(void)
+	{
+		int total, used;
+
+		if (getstats(&total, &used)) {
+			return NULL;
+		}
+
+		return fmt_human(used * 1024, 1024);
+	}
+#elif defined(__FreeBSD__)
+	#include <stdlib.h>
+	#include <sys/types.h>
+	#include <fcntl.h>
+	#include <unistd.h>
+	#include <kvm.h>
+
+	static int getswapinfo(struct kvm_swap *swap_info, size_t size)
+	{
+		kvm_t *kd;
+
+		kd = kvm_openfiles(NULL, "/dev/null", NULL, 0, NULL);
+		if(kd == NULL) {
+			warn("kvm_openfiles '/dev/null':");
+			return 0;
+		}
+
+		if(kvm_getswapinfo(kd, swap_info, size, 0 /* Unused flags */) == -1) {
+			warn("kvm_getswapinfo:");
+			kvm_close(kd);
+			return 0;
+		}
+
+		kvm_close(kd);
+		return 1;
+	}
+
+	const char *
+	swap_free(void)
+	{
+		struct kvm_swap swap_info[1];
+		long used, total;
+
+		if(!getswapinfo(swap_info, 1))
+			return NULL;
+
+		total = swap_info[0].ksw_total;
+		used = swap_info[0].ksw_used;
+
+		return fmt_human((total - used) * getpagesize(), 1024);
+	}
+
+	const char *
+	swap_perc(void)
+	{
+		struct kvm_swap swap_info[1];
+		long used, total;
+
+		if(!getswapinfo(swap_info, 1))
+			return NULL;
+
+		total = swap_info[0].ksw_total;
+		used = swap_info[0].ksw_used;
+
+		return bprintf("%d", used * 100 / total);
+	}
+
+	const char *
+	swap_total(void)
+	{
+		struct kvm_swap swap_info[1];
+		long total;
+
+		if(!getswapinfo(swap_info, 1))
+			return NULL;
+
+		total = swap_info[0].ksw_total;
+
+		return fmt_human(total * getpagesize(), 1024);
+	}
+
+	const char *
+	swap_used(void)
+	{
+		struct kvm_swap swap_info[1];
+		long used;
+
+		if(!getswapinfo(swap_info, 1))
+			return NULL;
+
+		used = swap_info[0].ksw_used;
+
+		return fmt_human(used * getpagesize(), 1024);
+	}
+#endif
diff --git a/components/swap.o b/components/swap.o
new file mode 100644
index 0000000000000000000000000000000000000000..499b27d472f9b1ff964423c0c180b4ef6b66bf25
GIT binary patch
literal 3968
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

literal 0
HcmV?d00001

diff --git a/components/temperature.c b/components/temperature.c
new file mode 100644
index 0000000..8e1f222
--- /dev/null
+++ b/components/temperature.c
@@ -0,0 +1,71 @@
+/* See LICENSE file for copyright and license details. */
+#include <stddef.h>
+
+#include "../util.h"
+
+
+#if defined(__linux__)
+	#include <stdint.h>
+
+	const char *
+	temp(const char *file)
+	{
+		uintmax_t temp;
+
+		if (pscanf(file, "%ju", &temp) != 1) {
+			return NULL;
+		}
+
+		return bprintf("%ju", temp / 1000);
+	}
+#elif defined(__OpenBSD__)
+	#include <stdio.h>
+	#include <sys/time.h> /* before <sys/sensors.h> for struct timeval */
+	#include <sys/sensors.h>
+	#include <sys/sysctl.h>
+
+	const char *
+	temp(const char *unused)
+	{
+		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) < 0) {
+			warn("sysctl 'SENSOR_TEMP':");
+			return NULL;
+		}
+
+		/* kelvin to celsius */
+		return bprintf("%d", (int)((float)(temp.value-273150000) / 1E6));
+	}
+#elif defined(__FreeBSD__)
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <sys/sysctl.h>
+
+	const char *
+	temp(const char *zone)
+	{
+		char buf[256];
+		int temp;
+		size_t len;
+
+		len = sizeof(temp);
+		snprintf(buf, sizeof(buf), "hw.acpi.thermal.%s.temperature", zone);
+		if (sysctlbyname(buf, &temp, &len, NULL, 0) == -1
+				|| !len)
+			return NULL;
+
+		/* kelvin to decimal celcius */
+		return bprintf("%d.%d", (temp - 2731) / 10, abs((temp - 2731) % 10));
+	}
+#endif
diff --git a/components/temperature.o b/components/temperature.o
new file mode 100644
index 0000000000000000000000000000000000000000..cce0bca170b19356ebd5d7f3acfe36c1c1044611
GIT binary patch
literal 1736
zcmbtT&ubG=5S~p_8?nZyJt$QOm`X+a%z6;<P?E+ZD}+Wg1wF{RNj4_7`Qc^*tsXoS
zgir+k4G)4>ZvjPm_T<@9K~a11BE*@OH_2v6E;=xoneUsK_jcaoMLL%WXd19+unMDy
zQ2=9R<R_$?fG`|~4dc}cg+}*>vHLwzHui!`%QC(d3+X+h`}Kh6WVe^>?|0549eaO(
zz4XsU_owmu(CB{Bdotx)0Mqvhu~6B#ydZnHvyw1&KSmyYSbEX{$fi;^qs!U#jZ0Bo
z7rKZ;5SvF)XHgM{0BAkJSTq&$H!Ubadv+JJ?TEHGKNot9<T=DiNow?y3`brD*2B@j
z{ct214iPj-sBaJs`;)kt36ne_6X~|&Lial5$(MIP>?~?zJXJ<lr{LG8;Hy(`aP4}_
zb}YB!*rEg?mx@aW%xo^dmdu&?Oy*v?U>1^VxwHwbcFAf~pxAP14YvZO*><hcrdg_P
zniZ?IMY9-401d6opZ-8DD4h5s9z5g0=RCOS!D;y1C#rDjPdXIQ-l@A*5k%W{2DZwc
zV{ci)wYOamWy`fd6x(eOPLl#k$4vrJYS!y^15+AJ*A}=+EArD+{J7B(EvJc-a(A$l
z8roH};#hTic!U3PqF7D4M6>ZqLIu1J%<(>Ryoe6XHo<_hchry`srVRLs^x_~qwtFg
z_x#Nz^G5N0<3IljCQ#3Rt=F-ZdR{~I3ZKt=#T=i{Hh~2BaZXV7t+J<mIM=bgjXe9_
z)Sfr+`2O4n$kG0e?IgxMR1*Kac>V(x;3+!P(_jBfCEVadW&QQ|*PHnM?^Hv6XL|pm
zs9ewZq_gR$W%Z$7C_tG<rMK|cQ&0cfBQ*S=ybMM^{`s9mYEu2ay8rW0sr3Bye*so%
BsB8cL

literal 0
HcmV?d00001

diff --git a/components/uptime.c b/components/uptime.c
new file mode 100644
index 0000000..7c23c98
--- /dev/null
+++ b/components/uptime.c
@@ -0,0 +1,33 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "../util.h"
+
+#if defined(CLOCK_BOOTTIME)
+	#define UPTIME_FLAG CLOCK_BOOTTIME
+#elif defined(CLOCK_UPTIME)
+	#define UPTIME_FLAG CLOCK_UPTIME
+#else
+	#define UPTIME_FLAG CLOCK_MONOTONIC
+#endif
+
+const char *
+uptime(void)
+{
+	char warn_buf[256];
+	uintmax_t h, m;
+	struct timespec uptime;
+
+	if (clock_gettime(UPTIME_FLAG, &uptime) < 0) {
+		snprintf(warn_buf, 256, "clock_gettime %d", UPTIME_FLAG);
+		warn(warn_buf);
+		return NULL;
+	}
+
+	h = uptime.tv_sec / 3600;
+	m = uptime.tv_sec % 3600 / 60;
+
+	return bprintf("%juh %jum", h, m);
+}
diff --git a/components/uptime.o b/components/uptime.o
new file mode 100644
index 0000000000000000000000000000000000000000..aa8f4edaf0b561fcd518814822b13f9b581c8b84
GIT binary patch
literal 2008
zcmbtU&1(}u6n{xu8@0x$6$16Jhg2%+()H+P(%N>FXhmDlgDl%*)5PY>%@$idNI}I=
z0v^105szMkUVG7?;@P8rf}kRvL=fux?apjBYjV*ayq))c?_*}?&CLC&>~u5|A&Cf`
zrEN>HMA!Sb^|Y&|DNcK6{>>m;`r228v-0|S|L7R(=7Us{39YTSoK);H5+1f!RlQYC
zB{$uS)<KY3`!%N1o8R3Sj`y`M<NEsfRBSU5XMgJqqV;F`&tIFTp*26~&5y3FH{WV)
zH(OtS>du<ij}E)ba0Wbn?LAg^^Ifi7%Pkp;mgAHvmNJ^B(Ob(!g+CRdnaRnM%Gk{1
z`6G&^shT>D35oFA3d;ZsJ1I($c3>-b@t)1~T?~sca`!4lRuYksp~2V_cBYs=Bz&(h
zX5xuQ(QJGp8hsv5Wa2U5>ouT$KmFM1=I_H6hOo=EvFc9jb<F|V*GUuBy+2ULT_bZN
zEQwGoOsxlht_QF8;4k&y=X>z9Tu1ZN9I4sKaeOpEkuj5<oycU3+3D$PQ**{#W+FRf
zP)E<HQLWphs#Bmlrd_24VHifkG5KWVic3bpER}ig!z=)Ljr00@%fl&<j3`SVi{vkY
zWFQ{Bl>8h>2Kb#Uk}rW|pbmVJe+-fV4n36o3)TVfyICZ!unwRO#E05gtvKcasSU^W
z#-h}0t8A){wc?PPHyxAIg+_x^y9NW{eEdnx)hZRM$|2R7W2t=fkGp#$?8WM`TDNO;
z%XU^d6$P!LQLxR5<*(qs6os>Ks&|B{q=hZdr*wyJ0M0G;DlG%Vm_*YUFTKItOXQ+w
zK++rB{(~3cf+hOqYn@7X{$uP$&410u{X)$XEJ4Wm@qa<c`Q?~qCv@?Q`JpipaKL9g
zMdr!z0@G3thK_V2yTsmL4)><xOtP(r{J+-4z94S1fzWXN6_K9~2D2{vCu!W_ZvAhI
zhR8nSF5zCve93p48@2J41M)wHSjQ_H&PUB~@0p?v@k0d|0f@3bgZH^x{wG1+^CLYa
Goc{+_jp022

literal 0
HcmV?d00001

diff --git a/components/user.c b/components/user.c
new file mode 100644
index 0000000..71a0c9d
--- /dev/null
+++ b/components/user.c
@@ -0,0 +1,32 @@
+/* See LICENSE file for copyright and license details. */
+#include <pwd.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "../util.h"
+
+const char *
+gid(void)
+{
+	return bprintf("%d", getgid());
+}
+
+const char *
+username(void)
+{
+	struct passwd *pw;
+
+	if (!(pw = getpwuid(geteuid()))) {
+		warn("getpwuid '%d':", geteuid());
+		return NULL;
+	}
+
+	return bprintf("%s", pw->pw_name);
+}
+
+const char *
+uid(void)
+{
+	return bprintf("%d", geteuid());
+}
diff --git a/components/user.o b/components/user.o
new file mode 100644
index 0000000000000000000000000000000000000000..7a69e2bb5c8bae08faf36571b5f076606f7c37d8
GIT binary patch
literal 2232
zcmb`H&rcIk5XWZ`qzW{M8Z~(61<^!SmYCQOHHD^tNfDz+0He)9mqMUF+%5t1;K>6q
zCjKA(10I{0=pW#PKS7V)O>n+%XUcYIFUCoBXWnOiytnVozIVC&OqXSmibW6UWTccR
z-E(4RjG3V%4bYRH7|eZq0JVDf&1w9CwPf(&_t5*k5e&_J7?&ugv0`GPnMgEar?L9A
zL(P#QmAs&~x4TtLjgAyYCuyWkG@H#%rf$wYets+EIJRStV|t=)ep38k+3ch)vKnA2
zmW=gVFNwo?^OUUpL2J0bH}Q#`;Mc`>1$rtuIG;=yc2~IhcIL0nClk58W%h=7i{g*w
z2|A^)j&AyWe9FP#Oq&zI9O2g)qxl*zRu2s|Noa)Q9<J3Y*sh^SeX~|((1Wd^W;E7;
zV=vmp-)D~cTG#9qvs{Px`3`)k1AoLE^;`Cu8SU0R-(Dv>pB=|*0xyROv-ySTseEB!
zX69LLv9LHbozE4}R;8^Xt=0UkO0Z#4D{k2X_qf}dZAW{qUqNx=ehLLWg|ql`9LhQ2
z@MEu)UlWe_z6ei6cz=Z75so^@(K^^qNW4xq#AaRSd5zBtM?88%IrbA0uk$j*rcQMI
z7lk7p->7x&b>O8AJS808rF#gJj&bdm<rvp<CcA!64%{`?fgkEkwR~^KwF7TIAiL-W
zF4=4KI@x{|1BCN6LH2sJT=ps)QmF=>%~!-&J#g2zWn8N4+BLsg^Zej|Q&G^{ENuAb
zivJ=hu7ZF5Y^+*F#@jKj_mtvcHgFah1)|gPgQq0{y#_P9FNm&6+zsIpE|lnV(`q&1
z^WSDSYW{1!!?~zA!B13l{>xFww$86QBTTOQW^_X=?N@bZo@(41YHJMikLVy`$75I6
z*UL||hY@~+7fXCyy8oe<=rtRt8P8A1M4K8YI-bA7yxsZN09ocjW$qgMubQvt-)?TC
s)O3E)xRcPM@qE;bpFJZwk`H=;K}4inlU!h{UH%tY|J!C{XvFjX0&42_zW@LL

literal 0
HcmV?d00001

diff --git a/components/volume.c b/components/volume.c
new file mode 100644
index 0000000..b6665da
--- /dev/null
+++ b/components/volume.c
@@ -0,0 +1,217 @@
+/* See LICENSE file for copyright and license details. */
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include "../util.h"
+
+#if defined(__OpenBSD__)
+	#include <sys/queue.h>
+	#include <poll.h>
+	#include <sndio.h>
+	#include <stdlib.h>
+
+	struct control {
+		LIST_ENTRY(control)	next;
+		unsigned int		addr;
+	#define CTRL_NONE	0
+	#define CTRL_LEVEL	1
+	#define CTRL_MUTE	2
+		unsigned int		type;
+		unsigned int		maxval;
+		unsigned int		val;
+	};
+
+	static LIST_HEAD(, control) controls = LIST_HEAD_INITIALIZER(controls);
+	static struct pollfd *pfds;
+	static struct sioctl_hdl *hdl;
+	static int initialized;
+
+	/*
+	 * Call-back to obtain the description of all audio controls.
+	 */
+	static void
+	ondesc(void *unused, struct sioctl_desc *desc, int val)
+	{
+		struct control *c, *ctmp;
+		unsigned int type = CTRL_NONE;
+
+		if (desc == NULL)
+			return;
+
+		/* Delete existing audio control with the same address. */
+		LIST_FOREACH_SAFE(c, &controls, next, ctmp) {
+			if (desc->addr == c->addr) {
+				LIST_REMOVE(c, next);
+				free(c);
+				break;
+			}
+		}
+
+		/* Only match output.level and output.mute audio controls. */
+		if (desc->group[0] != 0 ||
+		    strcmp(desc->node0.name, "output") != 0)
+			return;
+		if (desc->type == SIOCTL_NUM &&
+		    strcmp(desc->func, "level") == 0)
+			type = CTRL_LEVEL;
+		else if (desc->type == SIOCTL_SW &&
+			 strcmp(desc->func, "mute") == 0)
+			type = CTRL_MUTE;
+		else
+			return;
+
+		c = malloc(sizeof(struct control));
+		if (c == NULL) {
+			warn("sndio: failed to allocate audio control\n");
+			return;
+		}
+
+		c->addr = desc->addr;
+		c->type = type;
+		c->maxval = desc->maxval;
+		c->val = val;
+		LIST_INSERT_HEAD(&controls, c, next);
+	}
+
+	/*
+	 * Call-back invoked whenever an audio control changes.
+	 */
+	static void
+	onval(void *unused, unsigned int addr, unsigned int val)
+	{
+		struct control *c;
+
+		LIST_FOREACH(c, &controls, next) {
+			if (c->addr == addr)
+				break;
+		}
+		c->val = val;
+	}
+
+	static void
+	cleanup(void)
+	{
+		struct control *c;
+
+		if (hdl) {
+			sioctl_close(hdl);
+			hdl = NULL;
+		}
+
+		free(pfds);
+		pfds = NULL;
+
+		while (!LIST_EMPTY(&controls)) {
+			c = LIST_FIRST(&controls);
+			LIST_REMOVE(c, next);
+			free(c);
+		}
+	}
+
+	static int
+	init(void)
+	{
+		hdl = sioctl_open(SIO_DEVANY, SIOCTL_READ, 0);
+		if (hdl == NULL) {
+			warn("sndio: cannot open device");
+			goto failed;
+		}
+
+		if (!sioctl_ondesc(hdl, ondesc, NULL)) {
+			warn("sndio: cannot set control description call-back");
+			goto failed;
+		}
+
+		if (!sioctl_onval(hdl, onval, NULL)) {
+			warn("sndio: cannot set control values call-back");
+			goto failed;
+		}
+
+		pfds = calloc(sioctl_nfds(hdl), sizeof(struct pollfd));
+		if (pfds == NULL) {
+			warn("sndio: cannot allocate pollfd structures");
+			goto failed;
+		}
+
+		return 1;
+	failed:
+		cleanup();
+		return 0;
+	}
+
+	const char *
+	vol_perc(const char *unused)
+	{
+		struct control *c;
+		int n, v, value;
+
+		if (!initialized)
+			initialized = init();
+
+		if (hdl == NULL)
+			return NULL;
+
+		n = sioctl_pollfd(hdl, pfds, POLLIN);
+		if (n > 0) {
+			n = poll(pfds, n, 0);
+			if (n > 0) {
+				if (sioctl_revents(hdl, pfds) & POLLHUP) {
+					warn("sndio: disconnected");
+					cleanup();
+					return NULL;
+				}
+			}
+		}
+
+		value = 100;
+		LIST_FOREACH(c, &controls, next) {
+			if (c->type == CTRL_MUTE && c->val == 1)
+				value = 0;
+			else if (c->type == CTRL_LEVEL) {
+				v = (c->val * 100 + c->maxval / 2) / c->maxval;
+				/* For multiple channels return the minimum. */
+				if (v < value)
+					value = v;
+			}
+		}
+
+		return bprintf("%d", value);
+	}
+#else
+	#include <sys/soundcard.h>
+
+	const char *
+	vol_perc(const char *card)
+	{
+		size_t i;
+		int v, afd, devmask;
+		char *vnames[] = SOUND_DEVICE_NAMES;
+
+		if ((afd = open(card, O_RDONLY | O_NONBLOCK)) < 0) {
+			warn("open '%s':", card);
+			return NULL;
+		}
+
+		if (ioctl(afd, (int)SOUND_MIXER_READ_DEVMASK, &devmask) < 0) {
+			warn("ioctl 'SOUND_MIXER_READ_DEVMASK':");
+			close(afd);
+			return NULL;
+		}
+		for (i = 0; i < LEN(vnames); i++) {
+			if (devmask & (1 << i) && !strcmp("vol", vnames[i])) {
+				if (ioctl(afd, MIXER_READ(i), &v) < 0) {
+					warn("ioctl 'MIXER_READ(%ld)':", i);
+					close(afd);
+					return NULL;
+				}
+			}
+		}
+
+		close(afd);
+
+		return bprintf("%d", v & 0xff);
+	}
+#endif
diff --git a/components/volume.o b/components/volume.o
new file mode 100644
index 0000000000000000000000000000000000000000..4b9f16e14eff5bd580fe91892cfa5134c75aae0a
GIT binary patch
literal 3656
zcmds(O>7%g5P-+|X<P_SC<O(z5=J=0Rn%4N6etxxabhQ%)=8@TR6#Uso%JTRVtdVc
zlO|B9u3DfbL~133a^QfFfF3x&r79AtA_%lc1Q)o0Km}B!g5ba*BFyZ*ahw<X!jXyI
zo0;#;%zL~0o?p(!;{A0V53qRP8QAie0$jXn%kFW^9%um{L?+ag$H@OAj9p}Wu(UBT
zrk?xl7xa?qazlF%4YhP3@Ga`ln!0i((E8_l*TD-AFa1nW@XFfK1M$)=b>(UDLTe8E
z^)<9hH%ecqE8~G?^~RU~3^f!f|74&w7W&DFiLV@_49suco_xE1IT~n=mVWr=?<*cV
zdUW~FkMYtSG1>f~>wvYWuD5h2zWWw0V*idsh@8;c?MDVT*9XsUJUIWpU@ceefOq?>
z>hhb;Qzq5Uz0PCXjZSIx+&by!ry?gKQ=ij{|A%7cjhw%uz0h$4(xz@_{2gN>6T?w$
zXmBz%s*T1XQ7sxfF%%g)h7k*9hNHH|gYB8*0UT^k!gQig0NXOAGX@lva&`*xdKL<K
zBQa-KkV)qZ$fkABlc*MHEDV;RLwYum&VlLl6clno!%p7~$@FZ9x-fO!kWXQ3K4s3^
zu#ip~CRmAN+Jvl`OWUReFwoa`#2*|Oo;ctSg_Mxe<$kmVRDNuY*l-Z)z_Uh-#Up$^
zLwm)5=cQ5bEVg>~H8*)L;owuq_lvO*1^4<|SL%j+ZEw^^eg0P)BEI1H#sS}@x_Y0-
z7mWD)5nmgI^!mIasfMCb4e-Ziwc+}zCmWz1|Eftn?An3dpMjmc)rs5%&WWtZx?k|S
zD;Syk1P@94VZo0|yaW9`73+8288Z4T?%dlG`fKoGHTdxw{6q~tRfFp__*@N6XJI~T
zC^{(dzVH*&cRA)^r+<?A?k<Yb@`j~@HV_}_jl{K){{FGpxHcZ?jmI>g(+8&$R?a<E
zP_QjMn+H8(77UoqTj`uV1DaN_6Z)K{r{=VoL^^{ja`!RmI&8EHHa1;(mLLl4?PhGu
zhX|rjJe>jN;{;JC{vK@17YU*e_hDmxmLLk%q20v%b%H3wo3JszOb|t`|DlT=-hwvA
zuUGKOdA}B%>eEr;`0py>E7$*h1*d(+@qg9eyhW-0?uz&(I+!T5{(G@;orfy;o(hhp
zBkp;I^10&U&z!#pp8@8hBEL<l^PKSg64!(ulsN5Yk}g*{k4Miy`<djhtI9kt{2qzh
z!dE4JTKLB${<82VC0-Q%DT!YYeoErJpLkvTelCeP-k;3h61*tYd0Y4wCH}7PxgOW~
zK=4&5p7-lJ68~8ES0sK__#a99Q{i8e_-DdjllV>H`-P_cNv$kOVJT}Tra{5q4p*nx
zvW!eZv5iF=6vs>^>;x#&ct<OiNe<=U9SMqVX0t{P<8r2LD0n{}bbfM#KbxCZ@)rJ9
zS@x1BWu&wjE0HzI%lNN`9~0@_%QsUGG7`QoT+fYVn>5`=w6A-xZ4*&&m5QU#Zy}jp
za!}e_1)Zpg%QtCJ<nj9#;oxUO=togkn}3yl1W_i%$D;XZ4tajMM~TVvtJ^*@1_%+$
zViz7qi&(f!T!Zt!k~rtHj^Q}jT~b_|SkQeE=RDTKB3}xFPWgdE0OxW13uw@*k{`EA
z<jd>g_s97QXi!Z#|CGp|<Upb2{1=f|`+mREC4j>FguWmB55@V+tIbV$*Tnoc#RJpb
kR4t#TsrIUhbV;L}aaFmO-yhvc)$+YG8A{RVw>mlhUoRlUuK)l5

literal 0
HcmV?d00001

diff --git a/components/wifi.c b/components/wifi.c
new file mode 100644
index 0000000..92c252e
--- /dev/null
+++ b/components/wifi.c
@@ -0,0 +1,272 @@
+/* See LICENSE file for copyright and license details. */
+#include <ifaddrs.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include "../util.h"
+
+#define RSSI_TO_PERC(rssi) \
+			rssi >= -50 ? 100 : \
+			(rssi <= -100 ? 0 : \
+			(2 * (rssi + 100)))
+
+#if defined(__linux__)
+	#include <limits.h>
+	#include <linux/wireless.h>
+
+	const char *
+	wifi_perc(const char *interface)
+	{
+		int cur;
+		size_t i;
+		char *p, *datastart;
+		char path[PATH_MAX];
+		char status[5];
+		FILE *fp;
+
+		if (esnprintf(path, sizeof(path), "/sys/class/net/%s/operstate",
+		              interface) < 0) {
+			return NULL;
+		}
+		if (!(fp = fopen(path, "r"))) {
+			warn("fopen '%s':", path);
+			return NULL;
+		}
+		p = fgets(status, 5, fp);
+		fclose(fp);
+		if (!p || strcmp(status, "up\n") != 0) {
+			return NULL;
+		}
+
+		if (!(fp = fopen("/proc/net/wireless", "r"))) {
+			warn("fopen '/proc/net/wireless':");
+			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, interface))) {
+			return NULL;
+		}
+
+		datastart = (datastart+(strlen(interface)+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);
+
+		/* 70 is the max of /proc/net/wireless */
+		return bprintf("%d", (int)((float)cur / 70 * 100));
+	}
+
+	const char *
+	wifi_essid(const char *interface)
+	{
+		static char id[IW_ESSID_MAX_SIZE+1];
+		int sockfd;
+		struct iwreq wreq;
+
+		memset(&wreq, 0, sizeof(struct iwreq));
+		wreq.u.essid.length = IW_ESSID_MAX_SIZE+1;
+		if (esnprintf(wreq.ifr_name, sizeof(wreq.ifr_name), "%s",
+		              interface) < 0) {
+			return NULL;
+		}
+
+		if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+			warn("socket 'AF_INET':");
+			return NULL;
+		}
+		wreq.u.essid.pointer = id;
+		if (ioctl(sockfd,SIOCGIWESSID, &wreq) < 0) {
+			warn("ioctl 'SIOCGIWESSID':");
+			close(sockfd);
+			return NULL;
+		}
+
+		close(sockfd);
+
+		if (!strcmp(id, "")) {
+			return NULL;
+		}
+
+		return id;
+	}
+#elif defined(__OpenBSD__)
+	#include <net/if.h>
+	#include <net/if_media.h>
+	#include <net80211/ieee80211.h>
+	#include <sys/select.h> /* before <sys/ieee80211_ioctl.h> for NBBY */
+	#include <net80211/ieee80211_ioctl.h>
+	#include <stdlib.h>
+	#include <sys/types.h>
+
+	static int
+	load_ieee80211_nodereq(const char *interface, struct ieee80211_nodereq *nr)
+	{
+		struct ieee80211_bssid bssid;
+		int sockfd;
+		uint8_t zero_bssid[IEEE80211_ADDR_LEN];
+
+		memset(&bssid, 0, sizeof(bssid));
+		memset(nr, 0, sizeof(struct ieee80211_nodereq));
+		if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+			warn("socket 'AF_INET':");
+			return 0;
+		}
+		strlcpy(bssid.i_name, interface, sizeof(bssid.i_name));
+		if ((ioctl(sockfd, SIOCG80211BSSID, &bssid)) < 0) {
+			warn("ioctl 'SIOCG80211BSSID':");
+			close(sockfd);
+			return 0;
+		}
+		memset(&zero_bssid, 0, sizeof(zero_bssid));
+		if (memcmp(bssid.i_bssid, zero_bssid,
+		    IEEE80211_ADDR_LEN) == 0) {
+			close(sockfd);
+			return 0;
+		}
+		strlcpy(nr->nr_ifname, interface, sizeof(nr->nr_ifname));
+		memcpy(&nr->nr_macaddr, bssid.i_bssid, sizeof(nr->nr_macaddr));
+		if ((ioctl(sockfd, SIOCG80211NODE, nr)) < 0 && nr->nr_rssi) {
+			warn("ioctl 'SIOCG80211NODE':");
+			close(sockfd);
+			return 0;
+		}
+
+		return close(sockfd), 1;
+	}
+
+	const char *
+	wifi_perc(const char *interface)
+	{
+		struct ieee80211_nodereq nr;
+		int q;
+
+		if (load_ieee80211_nodereq(interface, &nr)) {
+			if (nr.nr_max_rssi) {
+				q = IEEE80211_NODEREQ_RSSI(&nr);
+			} else {
+				q = RSSI_TO_PERC(nr.nr_rssi);
+			}
+			return bprintf("%d", q);
+		}
+
+		return NULL;
+	}
+
+	const char *
+	wifi_essid(const char *interface)
+	{
+		struct ieee80211_nodereq nr;
+
+		if (load_ieee80211_nodereq(interface, &nr)) {
+			return bprintf("%s", nr.nr_nwid);
+		}
+
+		return NULL;
+	}
+#elif defined(__FreeBSD__)
+	#include <net/if.h>
+	#include <net80211/ieee80211_ioctl.h>
+
+	int
+	load_ieee80211req(int sock, const char *interface, void *data, int type, size_t *len)
+	{
+		char warn_buf[256];
+		struct ieee80211req ireq;
+		memset(&ireq, 0, sizeof(ireq));
+		ireq.i_type = type;
+		ireq.i_data = (caddr_t) data;
+		ireq.i_len = *len;
+
+		strlcpy(ireq.i_name, interface, sizeof(ireq.i_name));
+		if (ioctl(sock, SIOCG80211, &ireq) < 0) {
+			snprintf(warn_buf,  sizeof(warn_buf),
+					"ioctl: 'SIOCG80211': %d", type);
+			warn(warn_buf);
+			return 0;
+		}
+
+		*len = ireq.i_len;
+		return 1;
+	}
+
+	const char *
+	wifi_perc(const char *interface)
+	{
+		union {
+			struct ieee80211req_sta_req sta;
+			uint8_t buf[24 * 1024];
+		} info;
+		uint8_t bssid[IEEE80211_ADDR_LEN];
+		int rssi_dbm;
+		int sockfd;
+		size_t len;
+		const char *fmt;
+
+		if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+			warn("socket 'AF_INET':");
+			return NULL;
+		}
+
+		/* Retreive MAC address of interface */
+		len = IEEE80211_ADDR_LEN;
+		fmt = NULL;
+		if (load_ieee80211req(sockfd, interface, &bssid, IEEE80211_IOC_BSSID, &len))
+		{
+			/* Retrieve info on station with above BSSID */
+			memset(&info, 0, sizeof(info));
+			memcpy(info.sta.is_u.macaddr, bssid, sizeof(bssid));
+
+			len = sizeof(info);
+			if (load_ieee80211req(sockfd, interface, &info, IEEE80211_IOC_STA_INFO, &len)) {
+				rssi_dbm = info.sta.info[0].isi_noise +
+ 					         info.sta.info[0].isi_rssi / 2;
+
+				fmt = bprintf("%d", RSSI_TO_PERC(rssi_dbm));
+			}
+		}
+
+		close(sockfd);
+		return fmt;
+	}
+
+	const char *
+	wifi_essid(const char *interface)
+	{
+		char ssid[IEEE80211_NWID_LEN + 1];
+		size_t len;
+		int sockfd;
+		const char *fmt;
+
+		if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+			warn("socket 'AF_INET':");
+			return NULL;
+		}
+
+		fmt = NULL;
+		len = sizeof(ssid);
+		memset(&ssid, 0, len);
+		if (load_ieee80211req(sockfd, interface, &ssid, IEEE80211_IOC_SSID, &len )) {
+			if (len < sizeof(ssid))
+				len += 1;
+			else
+				len = sizeof(ssid);
+
+			ssid[len - 1] = '\0';
+			fmt = bprintf("%s", ssid);
+		}
+
+		close(sockfd);
+		return fmt;
+	}
+#endif
diff --git a/components/wifi.o b/components/wifi.o
new file mode 100644
index 0000000000000000000000000000000000000000..3381045881936f11f5234ccccc3b992eb7bbe1b8
GIT binary patch
literal 4336
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
KMNe~J_5T-PPY%cc

literal 0
HcmV?d00001

diff --git a/config.def.h b/config.def.h
new file mode 100644
index 0000000..3693afa
--- /dev/null
+++ b/config.def.h
@@ -0,0 +1,73 @@
+/* See LICENSE file for copyright and license details. */
+
+/* interval between updates (in ms) */
+const unsigned int interval = 1000;
+
+/* text to show if no value can be retrieved */
+static const char unknown_str[] = "n/a";
+
+/* maximum output string length */
+#define MAXLEN 2048
+
+/*
+ * function            description                     argument (example)
+ *
+ * battery_perc        battery percentage              battery name (BAT0)
+ *                                                     NULL on OpenBSD/FreeBSD
+ * battery_state       battery charging state          battery name (BAT0)
+ *                                                     NULL on OpenBSD/FreeBSD
+ * battery_remaining   battery remaining HH:MM         battery name (BAT0)
+ *                                                     NULL on OpenBSD/FreeBSD
+ * cpu_perc            cpu usage in percent            NULL
+ * cpu_freq            cpu frequency in MHz            NULL
+ * datetime            date and time                   format string (%F %T)
+ * disk_free           free disk space in GB           mountpoint path (/)
+ * disk_perc           disk usage in percent           mountpoint path (/)
+ * disk_total          total disk space in GB          mountpoint path (/")
+ * disk_used           used disk space in GB           mountpoint path (/)
+ * entropy             available entropy               NULL
+ * gid                 GID of current user             NULL
+ * hostname            hostname                        NULL
+ * ipv4                IPv4 address                    interface name (eth0)
+ * ipv6                IPv6 address                    interface name (eth0)
+ * kernel_release      `uname -r`                      NULL
+ * keyboard_indicators caps/num lock indicators        format string (c?n?)
+ *                                                     see keyboard_indicators.c
+ * keymap              layout (variant) of current     NULL
+ *                     keymap
+ * load_avg            load average                    NULL
+ * netspeed_rx         receive network speed           interface name (wlan0)
+ * netspeed_tx         transfer network speed          interface name (wlan0)
+ * num_files           number of files in a directory  path
+ *                                                     (/home/foo/Inbox/cur)
+ * ram_free            free memory in GB               NULL
+ * ram_perc            memory usage in percent         NULL
+ * ram_total           total memory size in GB         NULL
+ * ram_used            used memory in GB               NULL
+ * run_command         custom shell command            command (echo foo)
+ * separator           string to echo                  NULL
+ * swap_free           free swap in GB                 NULL
+ * swap_perc           swap usage in percent           NULL
+ * swap_total          total swap size in GB           NULL
+ * swap_used           used swap in GB                 NULL
+ * temp                temperature in degree celsius   sensor file
+ *                                                     (/sys/class/thermal/...)
+ *                                                     NULL on OpenBSD
+ *                                                     thermal zone on FreeBSD
+ *                                                     (tz0, tz1, etc.)
+ * uid                 UID of current user             NULL
+ * uptime              system uptime                   NULL
+ * username            username of current user        NULL
+ * vol_perc            OSS/ALSA volume in percent      mixer file (/dev/mixer)
+ *                                                     NULL on OpenBSD
+ * wifi_perc           WiFi signal in percent          interface name (wlan0)
+ * wifi_essid          WiFi ESSID                      interface name (wlan0)
+ */
+static const struct arg args[] = {
+	/* function format          argument */
+	{ cpu_perc, "[CPU %5s%%] ",    NULL },
+	{ ram_used, "[RAM %4s] ",      NULL },
+	{ username, "%3s@",            NULL },
+	{ hostname, "%2s ",            NULL },
+	{ datetime, "%s",           "%A %B %d %Y %r" },
+};
diff --git a/config.h b/config.h
new file mode 100644
index 0000000..3693afa
--- /dev/null
+++ b/config.h
@@ -0,0 +1,73 @@
+/* See LICENSE file for copyright and license details. */
+
+/* interval between updates (in ms) */
+const unsigned int interval = 1000;
+
+/* text to show if no value can be retrieved */
+static const char unknown_str[] = "n/a";
+
+/* maximum output string length */
+#define MAXLEN 2048
+
+/*
+ * function            description                     argument (example)
+ *
+ * battery_perc        battery percentage              battery name (BAT0)
+ *                                                     NULL on OpenBSD/FreeBSD
+ * battery_state       battery charging state          battery name (BAT0)
+ *                                                     NULL on OpenBSD/FreeBSD
+ * battery_remaining   battery remaining HH:MM         battery name (BAT0)
+ *                                                     NULL on OpenBSD/FreeBSD
+ * cpu_perc            cpu usage in percent            NULL
+ * cpu_freq            cpu frequency in MHz            NULL
+ * datetime            date and time                   format string (%F %T)
+ * disk_free           free disk space in GB           mountpoint path (/)
+ * disk_perc           disk usage in percent           mountpoint path (/)
+ * disk_total          total disk space in GB          mountpoint path (/")
+ * disk_used           used disk space in GB           mountpoint path (/)
+ * entropy             available entropy               NULL
+ * gid                 GID of current user             NULL
+ * hostname            hostname                        NULL
+ * ipv4                IPv4 address                    interface name (eth0)
+ * ipv6                IPv6 address                    interface name (eth0)
+ * kernel_release      `uname -r`                      NULL
+ * keyboard_indicators caps/num lock indicators        format string (c?n?)
+ *                                                     see keyboard_indicators.c
+ * keymap              layout (variant) of current     NULL
+ *                     keymap
+ * load_avg            load average                    NULL
+ * netspeed_rx         receive network speed           interface name (wlan0)
+ * netspeed_tx         transfer network speed          interface name (wlan0)
+ * num_files           number of files in a directory  path
+ *                                                     (/home/foo/Inbox/cur)
+ * ram_free            free memory in GB               NULL
+ * ram_perc            memory usage in percent         NULL
+ * ram_total           total memory size in GB         NULL
+ * ram_used            used memory in GB               NULL
+ * run_command         custom shell command            command (echo foo)
+ * separator           string to echo                  NULL
+ * swap_free           free swap in GB                 NULL
+ * swap_perc           swap usage in percent           NULL
+ * swap_total          total swap size in GB           NULL
+ * swap_used           used swap in GB                 NULL
+ * temp                temperature in degree celsius   sensor file
+ *                                                     (/sys/class/thermal/...)
+ *                                                     NULL on OpenBSD
+ *                                                     thermal zone on FreeBSD
+ *                                                     (tz0, tz1, etc.)
+ * uid                 UID of current user             NULL
+ * uptime              system uptime                   NULL
+ * username            username of current user        NULL
+ * vol_perc            OSS/ALSA volume in percent      mixer file (/dev/mixer)
+ *                                                     NULL on OpenBSD
+ * wifi_perc           WiFi signal in percent          interface name (wlan0)
+ * wifi_essid          WiFi ESSID                      interface name (wlan0)
+ */
+static const struct arg args[] = {
+	/* function format          argument */
+	{ cpu_perc, "[CPU %5s%%] ",    NULL },
+	{ ram_used, "[RAM %4s] ",      NULL },
+	{ username, "%3s@",            NULL },
+	{ hostname, "%2s ",            NULL },
+	{ datetime, "%s",           "%A %B %d %Y %r" },
+};
diff --git a/config.mk b/config.mk
new file mode 100644
index 0000000..2516e6e
--- /dev/null
+++ b/config.mk
@@ -0,0 +1,22 @@
+# slstatus version
+VERSION = 0
+
+# customize below to fit your system
+
+# paths
+PREFIX = /usr/local
+MANPREFIX = $(PREFIX)/share/man
+
+X11INC = /usr/X11R6/include
+X11LIB = /usr/X11R6/lib
+
+# flags
+CPPFLAGS = -I$(X11INC) -D_DEFAULT_SOURCE
+CFLAGS   = -std=c99 -pedantic -Wall -Wextra -Os
+LDFLAGS  = -L$(X11LIB) -s
+# OpenBSD: add -lsndio
+# FreeBSD: add -lkvm
+LDLIBS   = -lX11
+
+# compiler and linker
+CC = cc
diff --git a/slstatus b/slstatus
new file mode 100755
index 0000000000000000000000000000000000000000..3d30027e483e900aed88c8528dfaa17ed8cf3f7e
GIT binary patch
literal 31824
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
W%SdBo^Cb3pMwEYv6clMDR{3u+EO1Bw

literal 0
HcmV?d00001

diff --git a/slstatus.1 b/slstatus.1
new file mode 100644
index 0000000..d802037
--- /dev/null
+++ b/slstatus.1
@@ -0,0 +1,28 @@
+.Dd 2020-06-23
+.Dt SLSTATUS 1
+.Os
+.Sh NAME
+.Nm slstatus
+.Nd suckless status monitor
+.Sh SYNOPSIS
+.Nm
+.Op Fl s
+.Op Fl 1
+.Sh DESCRIPTION
+.Nm
+is a suckless status monitor for window managers that use WM_NAME (e.g. dwm) or
+stdin to fill the status bar.
+By default,
+.Nm
+outputs to WM_NAME.
+.Sh OPTIONS
+.Bl -tag -width Ds
+.It Fl s
+Write to stdout instead of WM_NAME.
+.It Fl 1
+Write once to stdout and quit.
+.El
+.Sh CUSTOMIZATION
+.Nm
+can be customized by creating a custom config.h and (re)compiling the source
+code. This keeps it fast, secure and simple.
diff --git a/slstatus.c b/slstatus.c
new file mode 100644
index 0000000..64da5cb
--- /dev/null
+++ b/slstatus.c
@@ -0,0 +1,141 @@
+/* See LICENSE file for copyright and license details. */
+#include <errno.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <X11/Xlib.h>
+
+#include "arg.h"
+#include "slstatus.h"
+#include "util.h"
+
+struct arg {
+	const char *(*func)();
+	const char *fmt;
+	const char *args;
+};
+
+char buf[1024];
+static volatile sig_atomic_t done;
+static Display *dpy;
+
+#include "config.h"
+
+static void
+terminate(const int signo)
+{
+	if (signo != SIGUSR1)
+		done = 1;
+}
+
+static void
+difftimespec(struct timespec *res, struct timespec *a, struct timespec *b)
+{
+	res->tv_sec = a->tv_sec - b->tv_sec - (a->tv_nsec < b->tv_nsec);
+	res->tv_nsec = a->tv_nsec - b->tv_nsec +
+	               (a->tv_nsec < b->tv_nsec) * 1E9;
+}
+
+static void
+usage(void)
+{
+	die("usage: %s [-s] [-1]", argv0);
+}
+
+int
+main(int argc, char *argv[])
+{
+	struct sigaction act;
+	struct timespec start, current, diff, intspec, wait;
+	size_t i, len;
+	int sflag, ret;
+	char status[MAXLEN];
+	const char *res;
+
+	sflag = 0;
+	ARGBEGIN {
+		case '1':
+			done = 1;
+			/* fallthrough */
+		case 's':
+			sflag = 1;
+			break;
+		default:
+			usage();
+	} ARGEND
+
+	if (argc) {
+		usage();
+	}
+
+	memset(&act, 0, sizeof(act));
+	act.sa_handler = terminate;
+	sigaction(SIGINT,  &act, NULL);
+	sigaction(SIGTERM, &act, NULL);
+	act.sa_flags |= SA_RESTART;
+	sigaction(SIGUSR1, &act, NULL);
+
+	if (!sflag && !(dpy = XOpenDisplay(NULL))) {
+		die("XOpenDisplay: Failed to open display");
+	}
+
+	do {
+		if (clock_gettime(CLOCK_MONOTONIC, &start) < 0) {
+			die("clock_gettime:");
+		}
+
+		status[0] = '\0';
+		for (i = len = 0; i < LEN(args); i++) {
+			if (!(res = args[i].func(args[i].args))) {
+				res = unknown_str;
+			}
+			if ((ret = esnprintf(status + len, sizeof(status) - len,
+			                    args[i].fmt, res)) < 0) {
+				break;
+			}
+			len += ret;
+		}
+
+		if (sflag) {
+			puts(status);
+			fflush(stdout);
+			if (ferror(stdout))
+				die("puts:");
+		} else {
+			if (XStoreName(dpy, DefaultRootWindow(dpy), status)
+                            < 0) {
+				die("XStoreName: Allocation failed");
+			}
+			XFlush(dpy);
+		}
+
+		if (!done) {
+			if (clock_gettime(CLOCK_MONOTONIC, &current) < 0) {
+				die("clock_gettime:");
+			}
+			difftimespec(&diff, &current, &start);
+
+			intspec.tv_sec = interval / 1000;
+			intspec.tv_nsec = (interval % 1000) * 1E6;
+			difftimespec(&wait, &intspec, &diff);
+
+			if (wait.tv_sec >= 0) {
+				if (nanosleep(&wait, NULL) < 0 &&
+				    errno != EINTR) {
+					die("nanosleep:");
+				}
+			}
+		}
+	} while (!done);
+
+	if (!sflag) {
+		XStoreName(dpy, DefaultRootWindow(dpy), NULL);
+		if (XCloseDisplay(dpy) < 0) {
+			die("XCloseDisplay: Failed to close display");
+		}
+	}
+
+	return 0;
+}
diff --git a/slstatus.h b/slstatus.h
new file mode 100644
index 0000000..b0f2564
--- /dev/null
+++ b/slstatus.h
@@ -0,0 +1,84 @@
+/* See LICENSE file for copyright and license details. */
+
+/* battery */
+const char *battery_perc(const char *);
+const char *battery_state(const char *);
+const char *battery_remaining(const char *);
+
+/* cpu */
+const char *cpu_freq(void);
+const char *cpu_perc(void);
+
+/* datetime */
+const char *datetime(const char *fmt);
+
+/* disk */
+const char *disk_free(const char *path);
+const char *disk_perc(const char *path);
+const char *disk_total(const char *path);
+const char *disk_used(const char *path);
+
+/* entropy */
+const char *entropy(void);
+
+/* hostname */
+const char *hostname(void);
+
+/* ip */
+const char *ipv4(const char *interface);
+const char *ipv6(const char *interface);
+
+/* kernel_release */
+const char *kernel_release(void);
+
+/* keyboard_indicators */
+const char *keyboard_indicators(void);
+
+/* keymap */
+const char *keymap(void);
+
+/* load_avg */
+const char *load_avg(void);
+
+/* netspeeds */
+const char *netspeed_rx(const char *interface);
+const char *netspeed_tx(const char *interface);
+
+/* num_files */
+const char *num_files(const char *path);
+
+/* ram */
+const char *ram_free(void);
+const char *ram_perc(void);
+const char *ram_total(void);
+const char *ram_used(void);
+
+/* run_command */
+const char *run_command(const char *cmd);
+
+/* separator */
+const char *separator(const char *separator);
+
+/* swap */
+const char *swap_free(void);
+const char *swap_perc(void);
+const char *swap_total(void);
+const char *swap_used(void);
+
+/* temperature */
+const char *temp(const char *);
+
+/* uptime */
+const char *uptime(void);
+
+/* user */
+const char *gid(void);
+const char *username(void);
+const char *uid(void);
+
+/* volume */
+const char *vol_perc(const char *card);
+
+/* wifi */
+const char *wifi_perc(const char *interface);
+const char *wifi_essid(const char *interface);
diff --git a/slstatus.o b/slstatus.o
new file mode 100644
index 0000000000000000000000000000000000000000..88fd6daa98da19eae83fe77f76399fa1499921ee
GIT binary patch
literal 6184
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
Uqbc_FX7&X+{+GcQ6{r1w0C&mvRsaA1

literal 0
HcmV?d00001

diff --git a/util.c b/util.c
new file mode 100644
index 0000000..85366bf
--- /dev/null
+++ b/util.c
@@ -0,0 +1,146 @@
+/* See LICENSE file for copyright and license details. */
+#include <errno.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util.h"
+
+char *argv0;
+
+static void
+verr(const char *fmt, va_list ap)
+{
+	if (argv0 && strncmp(fmt, "usage", sizeof("usage") - 1)) {
+		fprintf(stderr, "%s: ", argv0);
+	}
+
+	vfprintf(stderr, fmt, ap);
+
+	if (fmt[0] && fmt[strlen(fmt) - 1] == ':') {
+		fputc(' ', stderr);
+		perror(NULL);
+	} else {
+		fputc('\n', stderr);
+	}
+}
+
+void
+warn(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	verr(fmt, ap);
+	va_end(ap);
+}
+
+void
+die(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	verr(fmt, ap);
+	va_end(ap);
+
+	exit(1);
+}
+
+static int
+evsnprintf(char *str, size_t size, const char *fmt, va_list ap)
+{
+	int ret;
+
+	ret = vsnprintf(str, size, fmt, ap);
+
+	if (ret < 0) {
+		warn("vsnprintf:");
+		return -1;
+	} else if ((size_t)ret >= size) {
+		warn("vsnprintf: Output truncated");
+		return -1;
+	}
+
+	return ret;
+}
+
+int
+esnprintf(char *str, size_t size, const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = evsnprintf(str, size, fmt, ap);
+	va_end(ap);
+
+	return ret;
+}
+
+const char *
+bprintf(const char *fmt, ...)
+{
+	va_list ap;
+	int ret;
+
+	va_start(ap, fmt);
+	ret = evsnprintf(buf, sizeof(buf), fmt, ap);
+	va_end(ap);
+
+	return (ret < 0) ? NULL : buf;
+}
+
+const char *
+fmt_human(uintmax_t num, int base)
+{
+	double scaled;
+	size_t i, prefixlen;
+	const char **prefix;
+	const char *prefix_1000[] = { "", "k", "M", "G", "T", "P", "E", "Z",
+	                              "Y" };
+	const char *prefix_1024[] = { "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei",
+	                              "Zi", "Yi" };
+
+	switch (base) {
+	case 1000:
+		prefix = prefix_1000;
+		prefixlen = LEN(prefix_1000);
+		break;
+	case 1024:
+		prefix = prefix_1024;
+		prefixlen = LEN(prefix_1024);
+		break;
+	default:
+		warn("fmt_human: Invalid base");
+		return NULL;
+	}
+
+	scaled = num;
+	for (i = 0; i < prefixlen && scaled >= base; i++) {
+		scaled /= base;
+	}
+
+	return bprintf("%.1f %s", scaled, prefix[i]);
+}
+
+int
+pscanf(const char *path, const char *fmt, ...)
+{
+	FILE *fp;
+	va_list ap;
+	int n;
+
+	if (!(fp = fopen(path, "r"))) {
+		warn("fopen '%s':", path);
+		return -1;
+	}
+	va_start(ap, fmt);
+	n = vfscanf(fp, fmt, ap);
+	va_end(ap);
+	fclose(fp);
+
+	return (n == EOF) ? -1 : n;
+}
diff --git a/util.h b/util.h
new file mode 100644
index 0000000..7f1f26c
--- /dev/null
+++ b/util.h
@@ -0,0 +1,16 @@
+/* See LICENSE file for copyright and license details. */
+#include <stdint.h>
+
+extern char buf[1024];
+
+#define LEN(x) (sizeof (x) / sizeof *(x))
+
+extern char *argv0;
+
+void warn(const char *, ...);
+void die(const char *, ...);
+
+int esnprintf(char *str, size_t size, const char *fmt, ...);
+const char *bprintf(const char *fmt, ...);
+const char *fmt_human(uintmax_t num, int base);
+int pscanf(const char *path, const char *fmt, ...);
diff --git a/util.o b/util.o
new file mode 100644
index 0000000000000000000000000000000000000000..49112be5fa60387b0f68fe7fdeb2368126837c24
GIT binary patch
literal 5976
zcmdUzeQevs8OP6gp=l|$+rbF1mmlDaq+PwZ4BBQd#Cd71;I<h}*h(pm<JgVW#PRH(
zL%MZcqO=n~LPY-nt=c9)8fejks!l>v_gZHSgN+GwOp_{YgTfyyUCUtUkV;oAd%pL(
zvoBYBe@tT99_ijb_uSocchBAZ?5}r5HdlE(Oo@kmo|Q_9GIr!crF^T%wlW{{vT$#>
zXN&Xq9o+c`pFHo6OszxZ)<bXG>wa8IIX-;{z&xTu1-qV4eGb`(^A}kYDu_DCx$|1Y
zc~g+_&oDkE8r!#X=XLJbfjX&5x$*tgi!J#ZPgvBMODE_2p~YR{2g1A0Vgyd*6DugA
zp^5XSQA0g7a;GQI%$-PJW5nqQv_>e$4;JhVzNU^qx34J@=<_x81Twy+?*zuFjj!pM
zz+sU-7kFBv&j*f)^rwLWr2~AbrlFBCoO-Jd75MbQz!_0|>&2Qtovf(i(;Wc|D*hKc
z0yWKq=YR6g#YH|vjRyEyw+p-0ozTP_tUby9H>_3$3+v}=$?6mE6JaXt{sl7gl$hoR
zzoc)Fm%t2nIca_CY2c;y5g^wSu6C#}=Hu~GeADk9S|yS6xyhGk<$J`+Un@4RwDOqB
zu9G{qIG2j^`foVRM`3rwd6heFlsxG5pR*d8pXo*wC+z%!ro5Uvrzb8gRx@_MzjW5*
zod0&xG~pSt!dc+XMRMzv(ybp293dL|6`$UZg%=0&N2>{4cowL8DVn%6Pea>lCoaKu
zdks#6*bUdUrw)qVN-n?eT$WGMu|8Leq?^+WmMw7Kn!>s3xHCI>#>0PmmM@<LnqBaH
zsj%Q%^XpI{>HE}d_L>FXgR^|Gz$Y&*&%e#59#>tvdz!z2Pks8Aa`a;!J~4;coxPbH
zSlB|Ax#(oLcZ>5LZnMk1#ZCW!FA1@V5$DhDsyHvuyz|#boVSWQ7M}c#Yv#GTxbqHo
z-i$bZB~S3v6yPB5QmXrbcEQLl-w8W&ZnnZ515fX8&g{m;d6M$~r;^Xb_9R$CuEk=b
zxpXF*O54d6Eo*Jh+nKy=+1Y$L9<vhzEIDjP2lK<Rbc?kmJsKNI4OsoL9Q6?lC9Q@W
zV|&?F*2Q{QH|u2gvz_do6x*6&T`AU+V%;g$nPT^+*v=HovgAl6k+yDY$lcb$SXX;{
zi`Ce*t+&Yvg@U1Avsh6&1<ay=H<9XC74sCp)LZM3<>ka6*SZPweC1x|8S{H?TDh$5
zFe!hQ_(x>jb4c5~{^_bVZ~ddy9bRj)rpw!0bzp_pYWLPtO`Er_^J?OoRf*xMd_cDU
zA<{1I8Bf(wZyjYZ<`@{scM+kE5{trN3Xs!?!e0Mm)!k_LvezFLZ7ssjqmJY~L?xYh
zr31S~drIGjPM7zXr|Pv8FmfC9f|a@mPEw75#oRjO+`d6`d)HGn@3lILvk|IgBQ&pJ
ze_Je9SzTQ9rM1<J?yNFW&91tFV!db&i(Kplm97!wN`3e9>8dMwx<Tq+UF^xtd|dJm
z8@xgC^#)%n`P~K&N&Z!XZ;<?J2FE46N_eSTfq6pODfmThX|%Hfk5%BQ3Vg5v|8fNm
zKP_j^feQQ(@zu0nYM+Gf6MLkB{<o!mzuaPR9*8|vLH`-4Ut2{P66NPdDPPXc<HTXl
zpQOGxGsFrN^yj4htI|cq`62d-<S*kgAra?>(%(}kH|`%Q@beWo%iF1;V4RI6vRM|4
zw1+k!Uf(R@kciid_zn@@DdG(x-pFFvJ)_Mm+7;Q}7LG)>Z{ED4vnSdUZi{qAS<cR;
z<HH$B2hjCs(!I06hZ1R)q{}+aGE_B^We>%&X%>y<>{xtnG(NaDnvA7}*gz`55@RWw
zCDesqy6;)P?5;nbEZy`hlZ(gF1aMzdhpF61eAA}rXj0<%&<H&MLhxk+!S;A5TwZkL
zRzMPPoN~n*0ZFh8Sa-#52PA?1Dhi5=k0HsIX}p8-5cC5Zl>R+{BxXPNxmf7qj#2u3
zlAHP?nm+D(rH}Ig!MN8^Q2ajW|KRl+_n>1E@Ea*8{cma<_r2mzN{$3~isC=eINm<R
zk8Ay0uklkF*X`LZ&jqSKrs+Q{IqcN!c}&yS?fIU@b$gC#{pj|*pmE)v_qBeIRr6X2
zLr7pJxO$5}sd4;jRr(>xk?7-oU(?6iq4a;I>Ff5~RZB`F7<VNFrQanvn%%7Noti%0
zG^IbF>Ff4<OXIg_`p;_oR*j242dIp3bvvJ+G6WoNpBi@tkOW-!PXQ@{o1*Ss39zRS
z#do;H;+?2?ujH@+qWBlxBC}+wINm!*qni}<cgb?I!FS8@MuSIXxz*q?S?)8qn%AJg
z<FcGFcv6<f4375~GA`oMe1~NDVS}st;;_N9vV6qgd0Bqi;K~k5a`+*Fl0KPHT)or#
z4X)nf#|^ID-QxyV@9Q58uHMnh23PMW3+DC>+p&I1?W~&)s$4cP6bsskF`ETNb|7ZQ
zSg=2rqw)v}XhWa=EEpdd9!{i5FFj%>g7n?LPP}2VyeFLxX0r4aW$k^ktHfY5nT-u6
zq*ecUVo_80tobF{N(}OfJeO|C)m3?<H&MWOYNen{z59X7W^j3t;4Z;9>b%thlHhw3
zT&e*Hv7|vW3Mg)rKSAYk;}`I_k{m<lBp4rKnB(KS7t9?0B{{y*Clw)P`A(u3V!c~k
zj8%K5NZgDxN3;RyqyVPw12D)J@Ys{MzX#krVzd1=jg_?Mk4D*EXUMDeia$shsOo17
zb%V0KX_q<wQPM@9X8R+ueWNj;*&g5R<@PVLnkq<U+(hgj-aFM^`A@mA(WD?1`{c&L
p9r1l;w#VCT?mZ!9!C^=)xJfZKrX#-9%C)bT8#i8T>1NFK{{qnK|F!@C

literal 0
HcmV?d00001