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

use a static buffer instead of dynamic memory

master
Aaron Marcher 9 years ago
parent
abbaa7af44
commit
597cdc6b5c
No known key found for this signature in database GPG Key ID: 74B048E5C2474F9A
2 changed files with 204 additions and 242 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 5
      config.def.h
  2. 441
      slstatus.c

5
config.def.h
View File

@ -4,7 +4,10 @@
#define UPDATE_INTERVAL 1
/* text to show if no value can be retrieved */
#define UNKNOWN_STR "n/a"
#define UNKNOWN_STR "n/a"
/* maximum output string length */
#define MAXLEN 2048
/* statusbar
- battery_perc (battery percentage) [argument: battery name]

441
slstatus.c
View File

@ -28,45 +28,45 @@
#include "arg.h"
struct arg {
char *(*func)();
const char *(*func)();
const char *fmt;
const char *args;
};
static char *smprintf(const char *fmt, ...);
static char *battery_perc(const char *bat);
static char *battery_power(const char *bat);
static char *battery_state(const char *bat);
static char *cpu_freq(void);
static char *cpu_perc(void);
static char *datetime(const char *fmt);
static char *disk_free(const char *mnt);
static char *disk_perc(const char *mnt);
static char *disk_total(const char *mnt);
static char *disk_used(const char *mnt);
static char *entropy(void);
static char *gid(void);
static char *hostname(void);
static char *ip(const char *iface);
static char *kernel_release(void);
static char *keyboard_indicators(void);
static char *load_avg(void);
static char *ram_free(void);
static char *ram_perc(void);
static char *ram_used(void);
static char *ram_total(void);
static char *run_command(const char *cmd);
static char *swap_free(void);
static char *swap_perc(void);
static char *swap_used(void);
static char *swap_total(void);
static char *temp(const char *file);
static char *uid(void);
static char *uptime(void);
static char *username(void);
static char *vol_perc(const char *card);
static char *wifi_perc(const char *iface);
static char *wifi_essid(const char *iface);
static const char *bprintf(const char *fmt, ...);
static const char *battery_perc(const char *bat);
static const char *battery_power(const char *bat);
static const char *battery_state(const char *bat);
static const char *cpu_freq(void);
static const char *cpu_perc(void);
static const char *datetime(const char *fmt);
static const char *disk_free(const char *mnt);
static const char *disk_perc(const char *mnt);
static const char *disk_total(const char *mnt);
static const char *disk_used(const char *mnt);
static const char *entropy(void);
static const char *gid(void);
static const char *hostname(void);
static const char *ip(const char *iface);
static const char *kernel_release(void);
static const char *keyboard_indicators(void);
static const char *load_avg(void);
static const char *ram_free(void);
static const char *ram_perc(void);
static const char *ram_used(void);
static const char *ram_total(void);
static const char *run_command(const char *cmd);
static const char *swap_free(void);
static const char *swap_perc(void);
static const char *swap_used(void);
static const char *swap_total(void);
static const char *temp(const char *file);
static const char *uid(void);
static const char *uptime(void);
static const char *username(void);
static const char *vol_perc(const char *card);
static const char *wifi_perc(const char *iface);
static const char *wifi_essid(const char *iface);
static void sighandler(const int signo);
static void usage(const int eval);
@ -78,30 +78,25 @@ static Display *dpy;
#include "config.h"
static char *
smprintf(const char *fmt, ...)
static char buf[MAXLEN];
static const char *
bprintf(const char *fmt, ...)
{
va_list ap;
char *ret;
int len;
size_t len;
va_start(ap, fmt);
len = vsnprintf(NULL, 0, fmt, ap);
len = vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
va_end(ap);
ret = malloc(++len);
if (ret == NULL) {
err(1, "malloc");
}
if (len >= sizeof(buf))
buf[sizeof(buf)-1] = '\0';
va_start(ap, fmt);
vsnprintf(ret, len, fmt, ap);
va_end(ap);
return ret;
return buf;
}
static char *
static const char *
battery_perc(const char *bat)
{
int perc;
@ -112,15 +107,15 @@ battery_perc(const char *bat)
fp = fopen(path, "r");
if (fp == NULL) {
warn("Failed to open file %s", path);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%i", &perc);
fclose(fp);
return smprintf("%d", perc);
return bprintf("%d", perc);
}
static char *
static const char *
battery_power(const char *bat)
{
char path[PATH_MAX];
@ -131,15 +126,15 @@ battery_power(const char *bat)
fp = fopen(path, "r");
if (fp == NULL) {
warn("Failed to open file %s", path);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%i", &watts);
fclose(fp);
return smprintf("%d", (watts + 500000) / 1000000);
return bprintf("%d", (watts + 500000) / 1000000);
}
static char *
static const char *
battery_state(const char *bat)
{
char path[PATH_MAX];
@ -150,25 +145,25 @@ battery_state(const char *bat)
fp = fopen(path, "r");
if (fp == NULL) {
warn("Failed to open file %s", path);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%12s", state);
fclose(fp);
if (strcmp(state, "Charging") == 0) {
return smprintf("+");
return "+";
} else if (strcmp(state, "Discharging") == 0) {
return smprintf("-");
return "-";
} else if (strcmp(state, "Full") == 0) {
return smprintf("=");
return "=";
} else if (strcmp(state, "Unknown") == 0) {
return smprintf("/");
return "/";
} else {
return smprintf("?");
return "?";
}
}
static char *
static const char *
cpu_freq(void)
{
int freq;
@ -177,15 +172,15 @@ cpu_freq(void)
fp = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq", "r");
if (fp == NULL) {
warn("Failed to open file /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%i", &freq);
fclose(fp);
return smprintf("%d", (freq + 500) / 1000);
return bprintf("%d", (freq + 500) / 1000);
}
static char *
static const char *
cpu_perc(void)
{
int perc;
@ -195,7 +190,7 @@ cpu_perc(void)
fp = fopen("/proc/stat", "r");
if (fp == NULL) {
warn("Failed to open file /proc/stat");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2], &a[3]);
fclose(fp);
@ -206,43 +201,41 @@ cpu_perc(void)
fp = fopen("/proc/stat", "r");
if (fp == NULL) {
warn("Failed to open file /proc/stat");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &b[0], &b[1], &b[2], &b[3]);
fclose(fp);
perc = 100 * ((b[0]+b[1]+b[2]) - (a[0]+a[1]+a[2])) / ((b[0]+b[1]+b[2]+b[3]) - (a[0]+a[1]+a[2]+a[3]));
return smprintf("%d", perc);
return bprintf("%d", perc);
}
static char *
static const char *
datetime(const char *fmt)
{
time_t t;
char str[80];
t = time(NULL);
if (strftime(str, sizeof(str), fmt, localtime(&t)) == 0) {
return smprintf("%s", UNKNOWN_STR);
}
if (strftime(buf, sizeof(buf), fmt, localtime(&t)) == 0)
return UNKNOWN_STR;
return smprintf("%s", str);
return buf;
}
static char *
static const char *
disk_free(const char *mnt)
{
struct statvfs fs;
if (statvfs(mnt, &fs) < 0) {
warn("Failed to get filesystem info");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%f", (float)fs.f_bsize * (float)fs.f_bfree / 1024 / 1024 / 1024);
return bprintf("%f", (float)fs.f_bsize * (float)fs.f_bfree / 1024 / 1024 / 1024);
}
static char *
static const char *
disk_perc(const char *mnt)
{
int perc;
@ -250,41 +243,41 @@ disk_perc(const char *mnt)
if (statvfs(mnt, &fs) < 0) {
warn("Failed to get filesystem info");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
perc = 100 * (1.0f - ((float)fs.f_bfree / (float)fs.f_blocks));
return smprintf("%d", perc);
return bprintf("%d", perc);
}
static char *
static const char *
disk_total(const char *mnt)
{
struct statvfs fs;
if (statvfs(mnt, &fs) < 0) {
warn("Failed to get filesystem info");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%f", (float)fs.f_bsize * (float)fs.f_blocks / 1024 / 1024 / 1024);
return bprintf("%f", (float)fs.f_bsize * (float)fs.f_blocks / 1024 / 1024 / 1024);
}
static char *
static const char *
disk_used(const char *mnt)
{
struct statvfs fs;
if (statvfs(mnt, &fs) < 0) {
warn("Failed to get filesystem info");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%f", (float)fs.f_bsize * ((float)fs.f_blocks - (float)fs.f_bfree) / 1024 / 1024 / 1024);
return bprintf("%f", (float)fs.f_bsize * ((float)fs.f_blocks - (float)fs.f_bfree) / 1024 / 1024 / 1024);
}
static char *
static const char *
entropy(void)
{
int num;
@ -293,34 +286,32 @@ entropy(void)
fp= fopen("/proc/sys/kernel/random/entropy_avail", "r");
if (fp == NULL) {
warn("Failed to open file /proc/sys/kernel/random/entropy_avail");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%d", &num);
fclose(fp);
return smprintf("%d", num);
return bprintf("%d", num);
}
static char *
static const char *
gid(void)
{
return smprintf("%d", getgid());
return bprintf("%d", getgid());
}
static char *
static const char *
hostname(void)
{
char buf[HOST_NAME_MAX];
if (gethostname(buf, sizeof(buf)) == -1) {
warn("hostname");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%s", buf);
return buf;
}
static char *
static const char *
ip(const char *iface)
{
struct ifaddrs *ifaddr, *ifa;
@ -329,7 +320,7 @@ ip(const char *iface)
if (getifaddrs(&ifaddr) == -1) {
warn("Failed to get IP address for interface %s", iface);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
@ -340,30 +331,30 @@ ip(const char *iface)
if ((strcmp(ifa->ifa_name, iface) == 0) && (ifa->ifa_addr->sa_family == AF_INET)) {
if (s != 0) {
warnx("Failed to get IP address for interface %s", iface);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%s", host);
return bprintf("%s", host);
}
}
freeifaddrs(ifaddr);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
static char *
static const char *
kernel_release(void)
{
struct utsname udata;
if (uname(&udata) < 0) {
return smprintf(UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%s", udata.release);
return bprintf("%s", udata.release);
}
static char *
static const char *
keyboard_indicators(void)
{
Display *dpy = XOpenDisplay(NULL);
@ -373,33 +364,30 @@ keyboard_indicators(void)
switch (state.led_mask) {
case 1:
return smprintf("c");
break;
return "c";
case 2:
return smprintf("n");
break;
return "n";
case 3:
return smprintf("cn");
break;
return "cn";
default:
return smprintf("");
return "";
}
}
static char *
static const char *
load_avg(void)
{
double avgs[3];
if (getloadavg(avgs, 3) < 0) {
warnx("Failed to get the load avg");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%.2f %.2f %.2f", avgs[0], avgs[1], avgs[2]);
return bprintf("%.2f %.2f %.2f", avgs[0], avgs[1], avgs[2]);
}
static char *
static const char *
ram_free(void)
{
long free;
@ -408,15 +396,15 @@ ram_free(void)
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "MemFree: %ld kB\n", &free);
fclose(fp);
return smprintf("%f", (float)free / 1024 / 1024);
return bprintf("%f", (float)free / 1024 / 1024);
}
static char *
static const char *
ram_perc(void)
{
long total, free, buffers, cached;
@ -425,7 +413,7 @@ ram_perc(void)
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "MemTotal: %ld kB\n", &total);
fscanf(fp, "MemFree: %ld kB\n", &free);
@ -433,10 +421,10 @@ ram_perc(void)
fscanf(fp, "Cached: %ld kB\n", &cached);
fclose(fp);
return smprintf("%d", 100 * ((total - free) - (buffers + cached)) / total);
return bprintf("%d", 100 * ((total - free) - (buffers + cached)) / total);
}
static char *
static const char *
ram_total(void)
{
long total;
@ -445,15 +433,15 @@ ram_total(void)
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "MemTotal: %ld kB\n", &total);
fclose(fp);
return smprintf("%f", (float)total / 1024 / 1024);
return bprintf("%f", (float)total / 1024 / 1024);
}
static char *
static const char *
ram_used(void)
{
long free, total, buffers, cached;
@ -462,7 +450,7 @@ ram_used(void)
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "MemTotal: %ld kB\n", &total);
fscanf(fp, "MemFree: %ld kB\n", &free);
@ -470,184 +458,159 @@ ram_used(void)
fscanf(fp, "Cached: %ld kB\n", &cached);
fclose(fp);
return smprintf("%f", (float)(total - free - buffers - cached) / 1024 / 1024);
return bprintf("%f", (float)(total - free - buffers - cached) / 1024 / 1024);
}
static char *
static const char *
run_command(const char *cmd)
{
char *nlptr;
FILE *fp;
char buf[1024] = UNKNOWN_STR;
fp = popen(cmd, "r");
if (fp == NULL) {
warn("Failed to get command output for %s", cmd);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fgets(buf, sizeof(buf), fp);
fgets(buf, sizeof(buf) - 1, fp);
pclose(fp);
buf[sizeof(buf) - 1] = '\0';
if ((nlptr = strrchr(buf, '\n')) != NULL) {
if ((nlptr = strrchr(buf, '\n')) != NULL)
nlptr[0] = '\0';
}
return smprintf("%s", buf);
return buf[0] ? buf : UNKNOWN_STR;
}
static char *
static const char *
swap_free(void)
{
long total, free;
FILE *fp;
char buf[2048];
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) {
warn("swap_free: read error");
fclose(fp);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
buf[bytes_read] = '\0';
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapTotal")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapFree")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapFree")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapFree: %ld kB\n", &free);
return smprintf("%f", (float)free / 1024 / 1024);
return bprintf("%f", (float)free / 1024 / 1024);
}
static char *
static const char *
swap_perc(void)
{
long total, free, cached;
FILE *fp;
char buf[2048];
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) {
warn("swap_perc: read error");
fclose(fp);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
buf[bytes_read] = '\0';
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapTotal")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapCached")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapCached")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapCached: %ld kB\n", &cached);
if ((match = strstr(buf, "SwapFree")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapFree")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapFree: %ld kB\n", &free);
return smprintf("%d", 100 * (total - free - cached) / total);
return bprintf("%d", 100 * (total - free - cached) / total);
}
static char *
static const char *
swap_total(void)
{
long total;
FILE *fp;
char buf[2048];
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) {
warn("swap_total: read error");
fclose(fp);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
buf[bytes_read] = '\0';
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapTotal")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapTotal: %ld kB\n", &total);
return smprintf("%f", (float)total / 1024 / 1024);
return bprintf("%f", (float)total / 1024 / 1024);
}
static char *
static const char *
swap_used(void)
{
long total, free, cached;
FILE *fp;
char buf[2048];
size_t bytes_read;
char *match;
fp = fopen("/proc/meminfo", "r");
if (fp == NULL) {
warn("Failed to open file /proc/meminfo");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
if ((bytes_read = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) == 0) {
warn("swap_used: read error");
fclose(fp);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
buf[bytes_read] = '\0';
fclose(fp);
if ((match = strstr(buf, "SwapTotal")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapTotal")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapTotal: %ld kB\n", &total);
if ((match = strstr(buf, "SwapCached")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapCached")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapCached: %ld kB\n", &cached);
if ((match = strstr(buf, "SwapFree")) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((match = strstr(buf, "SwapFree")) == NULL)
return UNKNOWN_STR;
sscanf(match, "SwapFree: %ld kB\n", &free);
return smprintf("%f", (float)(total - free - cached) / 1024 / 1024);
return bprintf("%f", (float)(total - free - cached) / 1024 / 1024);
}
static char *
static const char *
temp(const char *file)
{
int temp;
@ -656,15 +619,15 @@ temp(const char *file)
fp = fopen(file, "r");
if (fp == NULL) {
warn("Failed to open file %s", file);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fscanf(fp, "%d", &temp);
fclose(fp);
return smprintf("%d", temp / 1000);
return bprintf("%d", temp / 1000);
}
static char *
static const char *
uptime(void)
{
struct sysinfo info;
@ -675,30 +638,30 @@ uptime(void)
h = info.uptime / 3600;
m = (info.uptime - h * 3600 ) / 60;
return smprintf("%dh %dm", h, m);
return bprintf("%dh %dm", h, m);
}
static char *
static const char *
username(void)
{
struct passwd *pw = getpwuid(geteuid());
if (pw == NULL) {
warn("Failed to get username");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
return smprintf("%s", pw->pw_name);
return bprintf("%s", pw->pw_name);
}
static char *
static const char *
uid(void)
{
return smprintf("%d", geteuid());
return bprintf("%d", geteuid());
}
static char *
static const char *
vol_perc(const char *card)
{
unsigned int i;
@ -708,34 +671,33 @@ vol_perc(const char *card)
afd = open(card, O_RDONLY | O_NONBLOCK);
if (afd == -1) {
warn("Cannot open %s", card);
return smprintf(UNKNOWN_STR);
return UNKNOWN_STR;
}
if (ioctl(afd, SOUND_MIXER_READ_DEVMASK, &devmask) == -1) {
warn("Cannot get volume for %s", card);
close(afd);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
for (i = 0; i < (sizeof(vnames) / sizeof((vnames[0]))); i++) {
if (devmask & (1 << i) && !strcmp("vol", vnames[i])) {
if (ioctl(afd, MIXER_READ(i), &v) == -1) {
warn("vol_perc: ioctl");
close(afd);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
}
}
close(afd);
return smprintf("%d", v & 0xff);
return bprintf("%d", v & 0xff);
}
static char *
static const char *
wifi_perc(const char *iface)
{
int perc;
char buf[255];
char *datastart;
char path[PATH_MAX];
char status[5];
@ -745,38 +707,38 @@ wifi_perc(const char *iface)
fp = fopen(path, "r");
if (fp == NULL) {
warn("Failed to open file %s", path);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fgets(status, 5, fp);
fclose(fp);
if(strcmp(status, "up\n") != 0) {
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fp = fopen("/proc/net/wireless", "r");
if (fp == NULL) {
warn("Failed to open file /proc/net/wireless");
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
fgets(buf, sizeof(buf), fp);
fgets(buf, sizeof(buf), fp);
fgets(buf, sizeof(buf), fp);
fgets(buf, sizeof(buf) - 1, fp);
fgets(buf, sizeof(buf) - 1, fp);
fgets(buf, sizeof(buf) - 1, fp);
fclose(fp);
if ((datastart = strstr(buf, iface)) == NULL) {
return smprintf("%s", UNKNOWN_STR);
}
if ((datastart = strstr(buf, iface)) == NULL)
return UNKNOWN_STR;
datastart = (datastart+(strlen(iface)+1));
sscanf(datastart + 1, " %*d %d %*d %*d %*d %*d %*d %*d %*d %*d", &perc);
return smprintf("%d", perc);
return bprintf("%d", perc);
}
static char *
static const char *
wifi_essid(const char *iface)
{
char id[IW_ESSID_MAX_SIZE+1];
static char id[IW_ESSID_MAX_SIZE+1];
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
struct iwreq wreq;
@ -786,20 +748,20 @@ wifi_essid(const char *iface)
if (sockfd == -1) {
warn("Failed to get ESSID for interface %s", iface);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
wreq.u.essid.pointer = id;
if (ioctl(sockfd,SIOCGIWESSID, &wreq) == -1) {
warn("Failed to get ESSID for interface %s", iface);
return smprintf("%s", UNKNOWN_STR);
return UNKNOWN_STR;
}
close(sockfd);
if (strcmp((char *)wreq.u.essid.pointer, "") == 0)
return smprintf("%s", UNKNOWN_STR);
if (strcmp(id, "") == 0)
return UNKNOWN_STR;
else
return smprintf("%s", (char *)wreq.u.essid.pointer);
return id;
}
static void
@ -821,10 +783,11 @@ int
main(int argc, char *argv[])
{
unsigned short int i;
char status_string[2048];
char *res, *element;
char status_string[MAXLEN];
char *element;
struct arg argument;
struct sigaction act;
size_t len;
ARGBEGIN {
case 'd':
@ -866,21 +829,17 @@ main(int argc, char *argv[])
while (!done) {
status_string[0] = '\0';
for (i = 0; i < sizeof(args) / sizeof(args[0]); ++i) {
for (element = status_string, i = len = 0;
i < sizeof(args) / sizeof(args[0]);
++i, element += len) {
argument = args[i];
if (argument.args == NULL) {
res = argument.func();
} else {
res = argument.func(argument.args);
}
element = smprintf(argument.fmt, res);
if (element == NULL) {
element = smprintf("%s", UNKNOWN_STR);
warnx("Failed to format output");
len = snprintf(element, sizeof(status_string)-1 - len,
argument.fmt,
argument.func(argument.args));
if (len >= sizeof(status_string)) {
status_string[sizeof(status_string)-1] = '\0';
break;
}
strncat(status_string, element, sizeof(status_string) - strlen(status_string) - 1);
free(res);
free(element);
}
if (oflag) {

Write Preview
Loading…
Cancel
Save