Xinqi Bao's Git

projects / slstatus.git / blob


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