add extra error tests to swap_*() && fix bytes_read bug

[slstatus.git] / slstatus.c

diff --git a/slstatus.c b/slstatus.c
index 9272c54..ac09c9f 100644 (file)
--- a/slstatus.c
+++ b/slstatus.c
@@ -6,6 +6,7 @@
 #include <ifaddrs.h>
 #include <limits.h>
 #include <linux/wireless.h>
 #include <ifaddrs.h>
 #include <limits.h>
 #include <linux/wireless.h>

+#include <locale.h>

 #include <netdb.h>
 #include <pwd.h>
 #include <signal.h>
 #include <netdb.h>
 #include <pwd.h>
 #include <signal.h>


@@ -19,6 +20,7 @@
 #include <sys/socket.h>
 #include <sys/sysinfo.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/sysinfo.h>
 #include <sys/types.h>

+#include <sys/utsname.h>

 #include <time.h>
 #include <unistd.h>
 #include <X11/Xlib.h>
 #include <time.h>
 #include <unistd.h>
 #include <X11/Xlib.h>


@@ -28,7 +30,6 @@
 
 #include "extern/arg.h"
 #include "extern/strlcat.h"
 
 #include "extern/arg.h"
 #include "extern/strlcat.h"

-#include "extern/strlcpy.h"

 #include "extern/concat.h"
 
 struct arg {
 #include "extern/concat.h"
 
 struct arg {


@@ -56,6 +57,10 @@ static char *ram_perc(void);
 static char *ram_used(void);
 static char *ram_total(void);
 static char *run_command(const char *cmd);
 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 *temp(const char *file);
 static char *uid(void);
 static char *uptime(void);


@@ -63,13 +68,14 @@ 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 char *vol_perc(const char *card);
 static char *wifi_perc(const char *iface);
 static char *wifi_essid(const char *iface);

+static char *kernel_release(void);

 static void set_status(const char *str);
 static void sighandler(const int signo);
 static void usage(void);
 
 char *argv0;
 char concat[];
 static void set_status(const char *str);
 static void sighandler(const int signo);
 static void usage(void);
 
 char *argv0;
 char concat[];

-static unsigned short int delay;
+static unsigned short int delay = 0;

 static unsigned short int done;
 static unsigned short int dflag, oflag;
 static Display *dpy;
 static unsigned short int done;
 static unsigned short int dflag, oflag;
 static Display *dpy;


@@ -158,7 +164,7 @@ cpu_perc(void)
        fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2], &a[3]);
        fclose(fp);
 
        fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2], &a[3]);
        fclose(fp);
 

-       delay = (UPDATE_INTERVAL - (UPDATE_INTERVAL - 1));
+       delay++;

        sleep(delay);
 
        fp = fopen("/proc/stat", "r");
        sleep(delay);
 
        fp = fopen("/proc/stat", "r");


@@ -399,21 +405,177 @@ ram_used(void)
 static char *
 run_command(const char *cmd)
 {
 static char *
 run_command(const char *cmd)
 {

+       char *nlptr;

        FILE *fp;
        FILE *fp;

-       char buf[64] = "n/a";
+       char buf[1024] = UNKNOWN_STR;

 
        fp = popen(cmd, "r");
        if (fp == NULL) {
                warn("Failed to get command output for %s", cmd);
                return smprintf(UNKNOWN_STR);
        }
 
        fp = popen(cmd, "r");
        if (fp == NULL) {
                warn("Failed to get command output for %s", cmd);
                return smprintf(UNKNOWN_STR);
        }

-       fgets(buf, sizeof(buf)-1, fp);
-       buf[strlen(buf)-1] = '\0';
+       fgets(buf, sizeof(buf), fp);

        pclose(fp);
        pclose(fp);

+       buf[strlen(buf)] = '\0';
+
+       if ((nlptr = strstr(buf, "\n")) != NULL) {
+               nlptr[0] = '\0';
+       }

 
        return smprintf("%s", buf);
 }
 
 
        return smprintf("%s", buf);
 }
 

+static 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(UNKNOWN_STR);
+       }
+
+       if ((bytes_read = fread(buf, sizeof(char), sizeof(buf), fp)) == 0) {
+               warn("swap_free: read error");
+               fclose(fp);
+               return smprintf("%s", UNKNOWN_STR);
+       }
+
+       buf[bytes_read] = '\0';
+       fclose(fp);
+
+       if ((match = strstr(buf, "SwapTotal")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapTotal: %ld kB\n", &total);
+
+       if ((match = strstr(buf, "SwapFree")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapFree: %ld kB\n", &free);
+
+       return smprintf("%f", (float)free / 1024 / 1024);
+}
+
+static 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(UNKNOWN_STR);
+       }
+
+       if ((bytes_read = fread(buf, sizeof(char), sizeof(buf), fp)) == 0) {
+               warn("swap_perc: read error");
+               fclose(fp);
+               return smprintf("%s", UNKNOWN_STR);
+       }
+
+       buf[bytes_read] = '\0';
+       fclose(fp);
+
+       if ((match = strstr(buf, "SwapTotal")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapTotal: %ld kB\n", &total);
+
+       if ((match = strstr(buf, "SwapCached")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapCached: %ld kB\n", &cached);
+
+       if ((match = strstr(buf, "SwapFree")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapFree: %ld kB\n", &free);
+
+       return smprintf("%d%%", 100 * (total - free - cached) / total);
+}
+
+static 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(UNKNOWN_STR);
+       }
+       if ((bytes_read = fread(buf, sizeof(char), sizeof(buf), fp)) == 0) {
+               warn("swap_total: read error");
+               fclose(fp);
+               return smprintf("%s", UNKNOWN_STR);
+       }
+
+       buf[bytes_read] = '\0';
+       fclose(fp);
+
+       if ((match = strstr(buf, "SwapTotal")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapTotal: %ld kB\n", &total);
+
+       return smprintf("%f", (float)total / 1024 / 1024);
+}
+
+static 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(UNKNOWN_STR);
+       }
+       if ((bytes_read = fread(buf, sizeof(char), sizeof(buf), fp)) == 0) {
+               warn("swap_used: read error");
+               fclose(fp);
+               return smprintf("%s", UNKNOWN_STR);
+       }
+
+       buf[bytes_read] = '\0';
+       fclose(fp);
+
+       if ((match = strstr(buf, "SwapTotal")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapTotal: %ld kB\n", &total);
+
+       if ((match = strstr(buf, "SwapCached")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapCached: %ld kB\n", &cached);
+
+       if ((match = strstr(buf, "SwapFree")) == NULL) {
+               return smprintf("%s", UNKNOWN_STR);
+       }
+       sscanf(match, "SwapFree: %ld kB\n", &free);
+
+       return smprintf("%f", (float)(total - free - cached) / 1024 / 1024);
+}
+

 static char *
 temp(const char *file)
 {
 static char *
 temp(const char *file)
 {


@@ -469,6 +631,7 @@ uid(void)
 static char *
 vol_perc(const char *card)
 {
 static char *
 vol_perc(const char *card)
 {

+       int mute;

        long int vol, max, min;
        snd_mixer_t *handle;
        snd_mixer_elem_t *elem;
        long int vol, max, min;
        snd_mixer_t *handle;
        snd_mixer_elem_t *elem;


@@ -492,11 +655,14 @@ vol_perc(const char *card)
        snd_mixer_handle_events(handle);
        snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
        snd_mixer_selem_get_playback_volume(elem, 0, &vol);
        snd_mixer_handle_events(handle);
        snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
        snd_mixer_selem_get_playback_volume(elem, 0, &vol);

+       snd_mixer_selem_get_playback_switch(elem, 0, &mute);

 
        snd_mixer_selem_id_free(s_elem);
        snd_mixer_close(handle);
 
 
        snd_mixer_selem_id_free(s_elem);
        snd_mixer_close(handle);
 

-       if (max == 0)
+       if (!mute)
+               return smprintf("mute");
+       else if (max == 0)

                return smprintf("0%%");
        else
                return smprintf("%lu%%", ((uint_fast16_t)(vol * 100) / max));
                return smprintf("0%%");
        else
                return smprintf("%lu%%", ((uint_fast16_t)(vol * 100) / max));


@@ -571,6 +737,16 @@ wifi_essid(const char *iface)
                return smprintf("%s", (char *)wreq.u.essid.pointer);
 }
 
                return smprintf("%s", (char *)wreq.u.essid.pointer);
 }
 

+static char *
+kernel_release(void)
+{
+       struct utsname udata;
+       if (uname(&udata) < 0)
+               return smprintf(UNKNOWN_STR);
+
+       return smprintf("%s", udata.release);
+}
+

 static void
 set_status(const char *str)
 {
 static void
 set_status(const char *str)
 {


@@ -597,7 +773,7 @@ int
 main(int argc, char *argv[])
 {
        unsigned short int i;
 main(int argc, char *argv[])
 {
        unsigned short int i;

-       char status_string[4096];
+       char status_string[2048];

        char *res, *element;
        struct arg argument;
        struct sigaction act;
        char *res, *element;
        struct arg argument;
        struct sigaction act;


@@ -619,8 +795,8 @@ main(int argc, char *argv[])
        if (dflag && oflag) {
                usage();
        }
        if (dflag && oflag) {
                usage();
        }

-       if (dflag) {
-               (void)daemon(1, 1);
+       if (dflag && daemon(1, 1) < 0) {
+               err(1, "daemon");

        }
 
        memset(&act, 0, sizeof(act));
        }
 
        memset(&act, 0, sizeof(act));


@@ -632,6 +808,8 @@ main(int argc, char *argv[])
                dpy = XOpenDisplay(NULL);
        }
 
                dpy = XOpenDisplay(NULL);
        }
 

+       setlocale(LC_ALL, "");
+

        while (!done) {
                status_string[0] = '\0';
 
        while (!done) {
                status_string[0] = '\0';
 


@@ -647,7 +825,8 @@ main(int argc, char *argv[])
                                element = smprintf(UNKNOWN_STR);
                                warnx("Failed to format output");
                        }
                                element = smprintf(UNKNOWN_STR);
                                warnx("Failed to format output");
                        }

-                       strlcat(status_string, element, sizeof(status_string));
+                       if (strlcat(status_string, element, sizeof(status_string)) >= sizeof(status_string))
+                               warnx("Output too long");

                        free(res);
                        free(element);
                }
                        free(res);
                        free(element);
                }


@@ -662,8 +841,13 @@ main(int argc, char *argv[])
                 * subtract delay time spend in function
                 * calls from the actual global delay time
                 */
                 * subtract delay time spend in function
                 * calls from the actual global delay time
                 */

-               sleep(UPDATE_INTERVAL - delay);
-               delay = 0;
+               if ((UPDATE_INTERVAL - delay) <= 0) {
+                       delay = 0;
+                       continue;
+               } else {
+                       sleep(UPDATE_INTERVAL - delay);
+                       delay = 0;
+               }

        }
 
        if (!oflag) {
        }
 
        if (!oflag) {