Xinqi Bao's Git

projects / slstatus.git / blob


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