slstatus.c

   1 /* See LICENSE file for copyright and license details. */
   2
   3 #include <alsa/asoundlib.h>
   4 #include <err.h>
   5 #include <fcntl.h>
   6 #include <ifaddrs.h>
   7 #include <limits.h>
   8 #include <linux/wireless.h>
   9 #include <netdb.h>
  10 #include <pwd.h>
  11 #include <signal.h>
  12 #include <stdarg.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <sys/ioctl.h>
  17 #include <sys/stat.h>
  18 #include <sys/statvfs.h>
  19 #include <sys/socket.h>
  20 #include <sys/sysinfo.h>
  21 #include <sys/types.h>
  22 #include <time.h>
  23 #include <unistd.h>
  24 #include <X11/Xlib.h>
  25
  26 #undef strlcat
  27 #undef strlcpy
  28
  29 #include "strlcat.h"
  30 #include "strlcpy.h"
  31 #include "concat.h"
  32
  33 char concat[];
  34
  35 struct arg {
  36         char *(*func)();
  37         const char *format;
  38         const char *args;
  39 };
  40
  41 static char *smprintf(const char *, ...);
  42 static char *battery_perc(const char *);
  43 static char *battery_state(const char *);
  44 static char *cpu_perc(void);
  45 static char *datetime(const char *);
  46 static char *disk_free(const char *);
  47 static char *disk_perc(const char *);
  48 static char *disk_total(const char *);
  49 static char *disk_used(const char *);
  50 static char *entropy(void);
  51 static char *gid(void);
  52 static char *hostname(void);
  53 static char *ip(const char *);
  54 static char *load_avg(void);
  55 static char *ram_free(void);
  56 static char *ram_perc(void);
  57 static char *ram_used(void);
  58 static char *ram_total(void);
  59 static char *run_command(const char *);
  60 static char *temp(const char *);
  61 static char *uid(void);
  62 static char *uptime(void);
  63 static char *username(void);
  64 static char *vol_perc(const char *);
  65 static char *wifi_perc(const char *);
  66 static char *wifi_essid(const char *);
  67 static void sighandler(const int);
  68
  69 static unsigned short int delay, done;
  70 static Display *dpy;
  71
  72 #include "config.h"
  73
  74 static char *
  75 smprintf(const char *fmt, ...)
  76 {
  77         va_list ap;
  78         char *ret;
  79         int len;
  80
  81         va_start(ap, fmt);
  82         len = vsnprintf(NULL, 0, fmt, ap);
  83         va_end(ap);
  84
  85         ret = malloc(++len);
  86         if (ret == NULL) {
  87                 perror("malloc");
  88                 exit(1);
  89         }
  90
  91         va_start(ap, fmt);
  92         vsnprintf(ret, len, fmt, ap);
  93         va_end(ap);
  94
  95         return ret;
  96 }
  97
  98 static char *
  99 battery_perc(const char *battery)
 100 {
 101         int perc;
 102         FILE *fp;
 103
 104         ccat(3, "/sys/class/power_supply/", battery, "/capacity");
 105         fp = fopen(concat, "r");
 106         if (fp == NULL) {
 107                 warn("Error opening battery file: %s", concat);
 108                 return smprintf(UNKNOWN_STR);
 109         }
 110         fscanf(fp, "%i", &perc);
 111         fclose(fp);
 112
 113         return smprintf("%d%%", perc);
 114 }
 115
 116 static char *
 117 battery_state(const char *battery)
 118 {
 119         char *state[12];
 120         FILE *fp;
 121
 122         if (!state) {
 123                 warn("Failed to get battery state.");
 124                 return smprintf(UNKNOWN_STR);
 125         }
 126
 127
 128         ccat(3, "/sys/class/power_supply/", battery, "/status");
 129         fp = fopen(concat, "r");
 130         if (fp == NULL) {
 131                 warn("Error opening battery file: %s", concat);
 132                 return smprintf(UNKNOWN_STR);
 133         }
 134         fscanf(fp, "%12s", state);
 135         fclose(fp);
 136
 137         if (strcmp(state, "Charging") == 0)
 138                 return smprintf("+");
 139         else if (strcmp(state, "Discharging") == 0)
 140                 return smprintf("-");
 141         else if (strcmp(state, "Full") == 0)
 142                 return smprintf("=");
 143         else
 144                 return smprintf("?");
 145 }
 146
 147 static char *
 148 cpu_perc(void)
 149 {
 150         int perc;
 151         long double a[4], b[4];
 152         FILE *fp = fopen("/proc/stat","r");
 153
 154         if (fp == NULL) {
 155                 warn("Error opening stat file");
 156                 return smprintf(UNKNOWN_STR);
 157         }
 158
 159         fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &a[0], &a[1], &a[2], &a[3]);
 160         fclose(fp);
 161
 162         delay = (UPDATE_INTERVAL - (UPDATE_INTERVAL - 1));
 163         sleep(delay);
 164
 165         fp = fopen("/proc/stat","r");
 166         if (fp == NULL) {
 167                 warn("Error opening stat file");
 168                 return smprintf(UNKNOWN_STR);
 169         }
 170
 171         fscanf(fp, "%*s %Lf %Lf %Lf %Lf", &b[0], &b[1], &b[2], &b[3]);
 172         fclose(fp);
 173         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]));
 174
 175         return smprintf("%d%%", perc);
 176 }
 177
 178 static char *
 179 datetime(const char *timeformat)
 180 {
 181         time_t t;
 182         char timestr[80];
 183
 184         t = time(NULL);
 185         if (strftime(timestr, sizeof(timestr), timeformat, localtime(&t)) == 0)
 186                 return smprintf(UNKNOWN_STR);
 187
 188         return smprintf("%s", timestr);
 189 }
 190
 191 static char *
 192 disk_free(const char *mountpoint)
 193 {
 194         struct statvfs fs;
 195
 196         if (statvfs(mountpoint, &fs) < 0) {
 197                 warn("Could not get filesystem info");
 198                 return smprintf(UNKNOWN_STR);
 199         }
 200
 201         return smprintf("%f", (float)fs.f_bsize * (float)fs.f_bfree / 1024 / 1024 / 1024);
 202 }
 203
 204 static char *
 205 disk_perc(const char *mountpoint)
 206 {
 207         int perc = 0;
 208         struct statvfs fs;
 209
 210         if (statvfs(mountpoint, &fs) < 0) {
 211                 warn("Could not get filesystem info");
 212                 return smprintf(UNKNOWN_STR);
 213         }
 214
 215         perc = 100 * (1.0f - ((float)fs.f_bfree / (float)fs.f_blocks));
 216
 217         return smprintf("%d%%", perc);
 218 }
 219
 220 static char *
 221 disk_total(const char *mountpoint)
 222 {
 223         struct statvfs fs;
 224
 225         if (statvfs(mountpoint, &fs) < 0) {
 226                 warn("Could not get filesystem info");
 227                 return smprintf(UNKNOWN_STR);
 228         }
 229
 230         return smprintf("%f", (float)fs.f_bsize * (float)fs.f_blocks / 1024 / 1024 / 1024);
 231 }
 232
 233 static char *
 234 disk_used(const char *mountpoint)
 235 {
 236         struct statvfs fs;
 237
 238         if (statvfs(mountpoint, &fs) < 0) {
 239                 warn("Could not get filesystem info");
 240                 return smprintf(UNKNOWN_STR);
 241         }
 242
 243         return smprintf("%f", (float)fs.f_bsize * ((float)fs.f_blocks - (float)fs.f_bfree) / 1024 / 1024 / 1024);
 244 }
 245
 246 static char *
 247 entropy(void)
 248 {
 249         int entropy = 0;
 250         FILE *fp = fopen("/proc/sys/kernel/random/entropy_avail", "r");
 251
 252         if (fp == NULL) {
 253                 warn("Could not open entropy file");
 254                 return smprintf(UNKNOWN_STR);
 255         }
 256
 257         fscanf(fp, "%d", &entropy);
 258         fclose(fp);
 259
 260         return smprintf("%d", entropy);
 261 }
 262
 263 static char *
 264 gid(void)
 265 {
 266         return smprintf("%d", getgid());
 267 }
 268
 269 static char *
 270 hostname(void)
 271 {
 272         char hostname[HOST_NAME_MAX];
 273         FILE *fp = fopen("/proc/sys/kernel/hostname", "r");
 274
 275         if (fp == NULL) {
 276                 warn("Could not open hostname file");
 277                 return smprintf(UNKNOWN_STR);
 278         }
 279
 280         fgets(hostname, sizeof(hostname), fp);
 281         /* FIXME: needs improvement */
 282         memset(&hostname[strlen(hostname)], '\0',
 283                 sizeof(hostname) - strlen(hostname));
 284         fclose(fp);
 285
 286         return smprintf("%s", hostname);
 287 }
 288
 289 static char *
 290 ip(const char *interface)
 291 {
 292         struct ifaddrs *ifaddr, *ifa;
 293         int s;
 294         char host[NI_MAXHOST];
 295
 296         if (getifaddrs(&ifaddr) == -1) {
 297                 warn("Error getting IP address");
 298                 return smprintf(UNKNOWN_STR);
 299         }
 300
 301         for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
 302                 if (ifa->ifa_addr == NULL)
 303                         continue;
 304
 305                 s = getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST,
 306                                                                 NULL, 0, NI_NUMERICHOST);
 307
 308                 if ((strcmp(ifa->ifa_name, interface) == 0) && (ifa->ifa_addr->sa_family == AF_INET)) {
 309                         if (s != 0) {
 310                                 warnx("Error getting IP address.");
 311                                 return smprintf(UNKNOWN_STR);
 312                         }
 313                         return smprintf("%s", host);
 314                 }
 315         }
 316
 317         freeifaddrs(ifaddr);
 318
 319         return smprintf(UNKNOWN_STR);
 320 }
 321
 322 static char *
 323 load_avg(void)
 324 {
 325         double avgs[3];
 326
 327         if (getloadavg(avgs, 3) < 0) {
 328                 warnx("Error getting load avg.");
 329                 return smprintf(UNKNOWN_STR);
 330         }
 331
 332         return smprintf("%.2f %.2f %.2f", avgs[0], avgs[1], avgs[2]);
 333 }
 334
 335 static char *
 336 ram_free(void)
 337 {
 338         long free;
 339         FILE *fp = fopen("/proc/meminfo", "r");
 340
 341         if (fp == NULL) {
 342                 warn("Error opening meminfo file");
 343                 return smprintf(UNKNOWN_STR);
 344         }
 345
 346         fscanf(fp, "MemFree: %ld kB\n", &free);
 347         fclose(fp);
 348
 349         return smprintf("%f", (float)free / 1024 / 1024);
 350 }
 351
 352 static char *
 353 ram_perc(void)
 354 {
 355         int perc;
 356         long total, free, buffers, cached;
 357         FILE *fp = fopen("/proc/meminfo", "r");
 358
 359         if (fp == NULL) {
 360                 warn("Error opening meminfo file");
 361                 return smprintf(UNKNOWN_STR);
 362         }
 363
 364         fscanf(fp, "MemTotal: %ld kB\n", &total);
 365         fscanf(fp, "MemFree: %ld kB\n", &free);
 366         fscanf(fp, "MemAvailable: %ld kB\nBuffers: %ld kB\n", &buffers, &buffers);
 367         fscanf(fp, "Cached: %ld kB\n", &cached);
 368
 369         fclose(fp);
 370         perc = 100 * ((total - free) - (buffers + cached)) / total;
 371
 372         return smprintf("%d%%", perc);
 373 }
 374
 375 static char *
 376 ram_total(void)
 377 {
 378         long total;
 379         FILE *fp = fopen("/proc/meminfo", "r");
 380
 381         if (fp == NULL) {
 382                 warn("Error opening meminfo file");
 383                 return smprintf(UNKNOWN_STR);
 384         }
 385
 386         fscanf(fp, "MemTotal: %ld kB\n", &total);
 387         fclose(fp);
 388
 389         return smprintf("%f", (float)total / 1024 / 1024);
 390 }
 391
 392 static char *
 393 ram_used(void)
 394 {
 395         long free, total, buffers, cached, used;
 396         FILE *fp = fopen("/proc/meminfo", "r");
 397
 398         if (fp == NULL) {
 399                 warn("Error opening meminfo file");
 400                 return smprintf(UNKNOWN_STR);
 401         }
 402
 403         fscanf(fp, "MemTotal: %ld kB\n", &total);
 404         fscanf(fp, "MemFree: %ld kB\n", &free);
 405         fscanf(fp, "MemAvailable: %ld kB\nBuffers: %ld kB\n", &buffers, &buffers);
 406         fscanf(fp, "Cached: %ld kB\n", &cached);
 407
 408         fclose(fp);
 409         used = total - free - buffers - cached;
 410
 411         return smprintf("%f", (float)used / 1024 / 1024);
 412 }
 413
 414 static char *
 415 run_command(const char* command)
 416 {
 417         int good;
 418         FILE *fp = popen(command, "r");
 419         char buffer[64] = "";
 420
 421         if (fp == NULL) {
 422                 warn("Could not get command output for: %s", command);
 423                 return smprintf(UNKNOWN_STR);
 424         }
 425
 426         fgets(buffer, sizeof(buffer)-1, fp);
 427         pclose(fp);
 428         for (int i = 0 ; i != sizeof(buffer); i++) {
 429                 if (buffer[i] == '\0') {
 430                         good = 1;
 431                         break;
 432                 }
 433         }
 434         if (good)
 435                 buffer[strlen(buffer)-1] = '\0';
 436
 437         return smprintf("%s", buffer);
 438 }
 439
 440 static char *
 441 temp(const char *file)
 442 {
 443         int temperature;
 444         FILE *fp = fopen(file, "r");
 445
 446         if (fp == NULL) {
 447                 warn("Could not open temperature file");
 448                 return smprintf(UNKNOWN_STR);
 449         }
 450
 451         fscanf(fp, "%d", &temperature);
 452         fclose(fp);
 453
 454         return smprintf("%d°C", temperature / 1000);
 455 }
 456
 457 static char *
 458 uptime(void)
 459 {
 460         struct sysinfo info;
 461         int hours = 0;
 462         int minutes = 0;
 463
 464         sysinfo(&info);
 465         hours = info.uptime / 3600;
 466         minutes = (info.uptime - hours * 3600 ) / 60;
 467
 468         return smprintf("%dh %dm", hours, minutes);
 469 }
 470
 471 static char *
 472 username(void)
 473 {
 474         uid_t uid = geteuid();
 475         struct passwd *pw = getpwuid(uid);
 476
 477         if (pw == NULL) {
 478                 warn("Could not get username");
 479                 return smprintf(UNKNOWN_STR);
 480         }
 481
 482         return smprintf("%s", pw->pw_name);
 483 }
 484
 485 static char *
 486 uid(void)
 487 {
 488         return smprintf("%d", geteuid());
 489 }
 490
 491
 492 static char *
 493 vol_perc(const char *soundcard)
 494 {
 495         long int vol, max, min;
 496         snd_mixer_t *handle;
 497         snd_mixer_elem_t *elem;
 498         snd_mixer_selem_id_t *s_elem;
 499
 500         snd_mixer_open(&handle, 0);
 501         snd_mixer_attach(handle, soundcard);
 502         snd_mixer_selem_register(handle, NULL, NULL);
 503         snd_mixer_load(handle);
 504         snd_mixer_selem_id_malloc(&s_elem);
 505         snd_mixer_selem_id_set_name(s_elem, "Master");
 506         elem = snd_mixer_find_selem(handle, s_elem);
 507
 508         if (elem == NULL) {
 509                 snd_mixer_selem_id_free(s_elem);
 510                 snd_mixer_close(handle);
 511                 warn("Failed to get volume percentage for: %s", soundcard);
 512                 return smprintf(UNKNOWN_STR);
 513         }
 514
 515         snd_mixer_handle_events(handle);
 516         snd_mixer_selem_get_playback_volume_range(elem, &min, &max);
 517         snd_mixer_selem_get_playback_volume(elem, 0, &vol);
 518
 519         snd_mixer_selem_id_free(s_elem);
 520         snd_mixer_close(handle);
 521
 522         return smprintf("%d%%", ((uint_fast16_t)(vol * 100) / max));
 523 }
 524
 525 static char *
 526 wifi_perc(const char *wificard)
 527 {
 528         int strength;
 529         char buf[255];
 530         char *datastart;
 531         char status[5];
 532         FILE *fp;
 533
 534         ccat(3, "/sys/class/net/", wificard, "/operstate");
 535
 536         fp = fopen(concat, "r");
 537
 538         if (fp == NULL) {
 539                 warn("Error opening wifi operstate file");
 540                 return smprintf(UNKNOWN_STR);
 541         }
 542
 543         fgets(status, 5, fp);
 544         fclose(fp);
 545         if(strcmp(status, "up\n") != 0)
 546                 return smprintf(UNKNOWN_STR);
 547
 548         fp = fopen("/proc/net/wireless", "r");
 549         if (fp == NULL) {
 550                 warn("Error opening wireless file");
 551                 return smprintf(UNKNOWN_STR);
 552         }
 553
 554         ccat(2, wificard, ":");
 555         fgets(buf, sizeof(buf), fp);
 556         fgets(buf, sizeof(buf), fp);
 557         fgets(buf, sizeof(buf), fp);
 558
 559         datastart = strstr(buf, concat);
 560         if (datastart != NULL) {
 561                 datastart = strstr(buf, ":");
 562                 sscanf(datastart + 1, " %*d   %d  %*d  %*d                %*d      %*d          %*d              %*d      %*d            %*d", &strength);
 563         }
 564
 565         fclose(fp);
 566
 567         return smprintf("%d%%", strength);
 568 }
 569
 570 static char *
 571 wifi_essid(const char *wificard)
 572 {
 573         char id[IW_ESSID_MAX_SIZE+1];
 574         int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
 575         struct iwreq wreq;
 576
 577         memset(&wreq, 0, sizeof(struct iwreq));
 578         wreq.u.essid.length = IW_ESSID_MAX_SIZE+1;
 579         sprintf(wreq.ifr_name, wificard);
 580         if (sockfd == -1) {
 581                 warn("Cannot open socket for interface: %s", wificard);
 582                 return smprintf(UNKNOWN_STR);
 583         }
 584         wreq.u.essid.pointer = id;
 585         if (ioctl(sockfd,SIOCGIWESSID, &wreq) == -1) {
 586                 warn("Get ESSID ioctl failed for interface %s", wificard);
 587                 return smprintf(UNKNOWN_STR);
 588         }
 589
 590         close(sockfd);
 591
 592         if (strcmp((char *)wreq.u.essid.pointer, "") == 0)
 593                 return smprintf(UNKNOWN_STR);
 594         else
 595                 return smprintf("%s", (char *)wreq.u.essid.pointer);
 596 }
 597
 598 static void
 599 sighandler(const int signo)
 600 {
 601         if (signo == SIGTERM || signo == SIGINT)
 602                 done = 1;
 603 }
 604
 605 int
 606 main(void)
 607 {
 608         unsigned short int i;
 609         char status_string[4096];
 610         char *res, *element, *status_old;
 611         struct arg argument;
 612         struct sigaction act;
 613
 614         memset(&act, 0, sizeof(act));
 615         act.sa_handler = sighandler;
 616         sigaction(SIGINT,  &act, 0);
 617         sigaction(SIGTERM, &act, 0);
 618
 619         dpy = XOpenDisplay(NULL);
 620
 621         while (!done) {
 622                 status_string[0] = '\0';
 623                 for (i = 0; i < sizeof(args) / sizeof(args[0]); ++i) {
 624                         argument = args[i];
 625                         if (argument.args == NULL)
 626                                 res = argument.func();
 627                         else
 628                                 res = argument.func(argument.args);
 629                         element = smprintf(argument.format, res);
 630                         if (element == NULL) {
 631                                 element = smprintf(UNKNOWN_STR);
 632                                 warnx("Failed to format output.");
 633                         }
 634                         strlcat(status_string, element, sizeof(status_string));
 635                         free(res);
 636                         free(element);
 637                 }
 638                 XStoreName(dpy, DefaultRootWindow(dpy), status_string);
 639                 XSync(dpy, False);
 640                 /*
 641                  * subtract delay time spend in function
 642                  * calls from the actual global delay time
 643                  */
 644                 sleep(UPDATE_INTERVAL - delay);
 645                 delay = 0;
 646         }
 647
 648         XStoreName(dpy, DefaultRootWindow(dpy), NULL);
 649         XSync(dpy, False);
 650
 651         XCloseDisplay(dpy);
 652
 653         return 0;
 654 }